diff --git a/src/Makefile.test.include b/src/Makefile.test.include
index f2c44568ef60..efc9a88fcfc3 100644
--- a/src/Makefile.test.include
+++ b/src/Makefile.test.include
@@ -82,6 +82,7 @@ BITCOIN_TESTS =\
   test/base32_tests.cpp \
   test/base58_tests.cpp \
   test/base64_tests.cpp \
+  test/baseindex_tests.cpp \
   test/bech32_tests.cpp \
   test/bip32_tests.cpp \
   test/bip324_tests.cpp \
diff --git a/src/index/addressindex.cpp b/src/index/addressindex.cpp
index 342de4e359d6..8ce3783ea36f 100644
--- a/src/index/addressindex.cpp
+++ b/src/index/addressindex.cpp
@@ -141,11 +141,9 @@ bool AddressIndex::DB::UpdateAddressUnspentIndex(const std::vector<CAddressUnspe
     return CDBWrapper::WriteBatch(batch);
 }
 
-bool AddressIndex::DB::RewindBatch(const std::vector<CAddressIndexEntry>& address_entries,
+void AddressIndex::DB::RewindBatch(CDBBatch& batch, const std::vector<CAddressIndexEntry>& address_entries,
                                    const std::vector<CAddressUnspentIndexEntry>& unspent_entries)
 {
-    CDBBatch batch(*this);
-
     for (const auto& [key, _] : address_entries) {
         batch.Erase(std::make_pair(DB_ADDRESSINDEX, key));
     }
@@ -157,8 +155,6 @@ bool AddressIndex::DB::RewindBatch(const std::vector<CAddressIndexEntry>& addres
             batch.Write(std::make_pair(DB_ADDRESSUNSPENTINDEX, key), value);
         }
     }
-
-    return CDBWrapper::WriteBatch(batch);
 }
 
 AddressIndex::AddressIndex(std::unique_ptr<interfaces::Chain> chain, size_t n_cache_size, bool f_memory, bool f_wipe) :
@@ -285,17 +281,17 @@ bool AddressIndex::CustomRewind(const interfaces::BlockKey& current_tip, const i
 
     // Rewind the unspent index by processing blocks in reverse
     // We need to undo all operations from current_tip back to (but not including) new_tip
-    for (const CBlockIndex* pindex = current_tip_index; pindex != new_tip_index; pindex = pindex->pprev) {
+    return RewindBlockByBlock(current_tip_index, new_tip_index, [&](const CBlockIndex* pindex, CDBBatch& batch) {
         CBlock block;
         if (!node::ReadBlockFromDisk(block, pindex, Params().GetConsensus())) {
-            LogError("%s: Failed to read block %s from disk during rewind\n", __func__,
+            LogError("%s: Failed to read block %s from disk during rewind\n", "CustomRewind",
                      pindex->GetBlockHash().ToString());
             return false;
         }
 
         CBlockUndo blockundo;
         if (pindex->nHeight > 0 && !node::UndoReadFromDisk(blockundo, pindex)) {
-            LogError("%s: Failed to read undo data for block %s during rewind\n", __func__,
+            LogError("%s: Failed to read undo data for block %s during rewind\n", "CustomRewind",
                      pindex->GetBlockHash().ToString());
             return false;
         }
@@ -308,7 +304,7 @@ bool AddressIndex::CustomRewind(const interfaces::BlockKey& current_tip, const i
         // reverse order ensures spends are undone before outputs, preventing phantom UTXOs.
         // blockundo.vtxundo[i] corresponds to block.vtx[i+1] (coinbase skipped)
         if (blockundo.vtxundo.size() != block.vtx.size() - 1) {
-            LogError("%s: Undo data size mismatch for block %s (expected %zu, got %zu)\n", __func__,
+            LogError("%s: Undo data size mismatch for block %s (expected %zu, got %zu)\n", "CustomRewind",
                      pindex->GetBlockHash().ToString(), block.vtx.size() - 1, blockundo.vtxundo.size());
             return false;
         }
@@ -340,7 +336,7 @@ bool AddressIndex::CustomRewind(const interfaces::BlockKey& current_tip, const i
 
             // Undo inputs (restore to unspent index, remove spending from history)
             if (tx->vin.size() != txundo.vprevout.size()) {
-                LogError("%s: Undo data mismatch for tx %s\n", __func__, txhash.ToString());
+                LogError("%s: Undo data mismatch for tx %s\n", "CustomRewind", txhash.ToString());
                 return false;
             }
 
@@ -391,14 +387,9 @@ bool AddressIndex::CustomRewind(const interfaces::BlockKey& current_tip, const i
             }
         }
 
-        // Apply both rewind updates in a single batch to avoid leaving the index half-rewound.
-        if (!m_db->RewindBatch(addressIndex, addressUnspentIndex)) {
-            LogError("%s: Failed to apply address index rewind batch\n", __func__);
-            return false;
-        }
-    }
-
-    return true;
+        m_db->RewindBatch(batch, addressIndex, addressUnspentIndex);
+        return true;
+    });
 }
 
 BaseIndex::DB& AddressIndex::GetDB() const { return *m_db; }
diff --git a/src/index/addressindex.h b/src/index/addressindex.h
index 06497faba7cf..265e5243dbdd 100644
--- a/src/index/addressindex.h
+++ b/src/index/addressindex.h
@@ -54,13 +54,14 @@ class AddressIndex final : public BaseIndex
         /// Update address unspent index (handles both adds and deletes)
         bool UpdateAddressUnspentIndex(const std::vector<CAddressUnspentIndexEntry>& entries);
 
-        /// Atomically erase address history entries and update unspent outputs during rewind.
-        bool RewindBatch(const std::vector<CAddressIndexEntry>& address_entries,
+        /// Add the erasures of address history entries and the unspent output updates of a rewind to batch.
+        void RewindBatch(CDBBatch& batch, const std::vector<CAddressIndexEntry>& address_entries,
                          const std::vector<CAddressUnspentIndexEntry>& unspent_entries);
     };
 
     /// Override to return false - we need undo data
     bool AllowPrune() const override { return false; }
+    bool WritesEagerly() const override { return true; }
 
     /// Write block data to the index databases
     bool CustomAppend(const interfaces::BlockInfo& block) override;
diff --git a/src/index/base.cpp b/src/index/base.cpp
index 42f6f12df59c..bbdc430b0218 100644
--- a/src/index/base.cpp
+++ b/src/index/base.cpp
@@ -27,6 +27,7 @@ using node::ReadBlockFromDisk;
 using node::g_indexes_ready_to_sync;
 
 constexpr uint8_t DB_BEST_BLOCK{'B'};
+constexpr uint8_t DB_UNCOMMITTED_TIP{'U'};
 
 constexpr auto SYNC_LOG_INTERVAL{30s};
 constexpr auto SYNC_LOCATOR_WRITE_INTERVAL{30s};
@@ -55,13 +56,16 @@ BaseIndex::DB::DB(const fs::path& path, size_t n_cache_size, bool f_memory, bool
         .options = [] { DBOptions options; node::ReadDatabaseArgs(gArgs, options); return options; }()}}
 {}
 
-bool BaseIndex::DB::ReadBestBlock(CBlockLocator& locator) const
+CBlockLocator BaseIndex::DB::ReadBestBlock() const
 {
+    CBlockLocator locator;
+
     bool success = Read(DB_BEST_BLOCK, locator);
     if (!success) {
         locator.SetNull();
     }
-    return success;
+
+    return locator;
 }
 
 void BaseIndex::DB::WriteBestBlock(CDBBatch& batch, const CBlockLocator& locator)
@@ -69,6 +73,23 @@ void BaseIndex::DB::WriteBestBlock(CDBBatch& batch, const CBlockLocator& locator
     batch.Write(DB_BEST_BLOCK, locator);
 }
 
+std::optional<uint256> BaseIndex::DB::ReadUncommittedTip() const
+{
+    uint256 block_hash;
+    if (!Read(DB_UNCOMMITTED_TIP, block_hash)) return std::nullopt;
+    return block_hash;
+}
+
+void BaseIndex::DB::WriteUncommittedTip(CDBBatch& batch, const uint256& block_hash)
+{
+    batch.Write(DB_UNCOMMITTED_TIP, block_hash);
+}
+
+void BaseIndex::DB::EraseUncommittedTip(CDBBatch& batch)
+{
+    batch.Erase(DB_UNCOMMITTED_TIP);
+}
+
 BaseIndex::BaseIndex(std::unique_ptr<interfaces::Chain> chain, std::string name)
     : m_chain{std::move(chain)}, m_name{std::move(name)} {}
 
@@ -80,24 +101,34 @@ BaseIndex::~BaseIndex()
 
 bool BaseIndex::Init()
 {
-    CBlockLocator locator;
-    if (!GetDB().ReadBestBlock(locator)) {
-        locator.SetNull();
-    }
+    const auto locator{GetDB().ReadBestBlock()};
 
     LOCK(cs_main);
     CChain& active_chain = m_chainstate->m_chain;
-    if (locator.IsNull()) {
-        SetBestBlockIndex(nullptr);
-    } else {
+    const CBlockIndex* locator_index{nullptr};
+    if (!locator.IsNull()) {
         // Setting the best block to the locator's top block. If it is not part of the
         // best chain, we will rewind to the fork point during index sync
-        const CBlockIndex* locator_index{m_chainstate->m_blockman.LookupBlockIndex(locator.vHave.at(0))};
+        locator_index = m_chainstate->m_blockman.LookupBlockIndex(locator.vHave.at(0));
         if (!locator_index) {
             return InitError(strprintf(Untranslated("%s: best block of the index not found. Please rebuild the index."), GetName()));
         }
-        SetBestBlockIndex(locator_index);
     }
+    const CBlockIndex* resume_block{ResumeBlock(m_chainstate->m_blockman, locator_index)};
+    const auto uncommitted_tip{WritesEagerly() ? GetDB().ReadUncommittedTip() : std::nullopt};
+    if (uncommitted_tip && resume_block == locator_index) {
+        // The entries of the blocks up to it are on disk, but without the blocks the index can't tell whether they
+        // are still on the active chain, nor rewind them.
+        if (!m_chainstate->m_blockman.LookupBlockIndex(*uncommitted_tip)) {
+            return InitError(strprintf(Untranslated("%s: the block the index was last synced to is not found. Please "
+                                                    "rebuild the index."),
+                                       GetName()));
+        }
+        CDBBatch batch(GetDB());
+        GetDB().EraseUncommittedTip(batch);
+        GetDB().WriteBatch(batch);
+    }
+    SetBestBlockIndex(resume_block);
 
     // Skip pruning check if indexes are not ready to sync (because reindex-chainstate has wiped the chain).
     const CBlockIndex* start_block = m_best_block_index.load();
@@ -157,11 +188,17 @@ static const CBlockIndex* NextSyncBlock(const CBlockIndex* pindex_prev, CChain&
         return chain.Genesis();
     }
 
-    const CBlockIndex* pindex = chain.Next(pindex_prev);
-    if (pindex) {
+    if (const auto* pindex{chain.Next(pindex_prev)}) {
         return pindex;
     }
 
+    // If there is no next block, we might be synced
+    if (pindex_prev == chain.Tip()) {
+        return nullptr;
+    }
+
+    // Since block is not in the chain, return the next block in the chain AFTER the last common ancestor.
+    // Caller will be responsible for rewinding back to the common ancestor.
     return chain.Next(chain.FindFork(pindex_prev));
 }
 
@@ -177,8 +214,8 @@ void BaseIndex::ThreadSync()
     if (!m_synced) {
         auto& consensus_params = Params().GetConsensus();
 
-        std::chrono::steady_clock::time_point last_log_time{0s};
-        std::chrono::steady_clock::time_point last_locator_write_time{0s};
+        auto last_log_time{NodeClock::now()};
+        auto last_locator_write_time{last_log_time};
         while (true) {
             if (m_interrupt) {
                 SetBestBlockIndex(pindex);
@@ -222,14 +259,14 @@ void BaseIndex::ThreadSync()
                 return;
             }
 
-            auto current_time{std::chrono::steady_clock::now()};
-            if (last_log_time + SYNC_LOG_INTERVAL < current_time) {
+            auto current_time{NodeClock::now()};
+            if (current_time - last_log_time >= SYNC_LOG_INTERVAL) {
                 LogPrintf("Syncing %s with block chain from height %d\n",
                           GetName(), pindex->nHeight);
                 last_log_time = current_time;
             }
 
-            if (last_locator_write_time + SYNC_LOCATOR_WRITE_INTERVAL < current_time) {
+            if (current_time - last_locator_write_time >= SYNC_LOCATOR_WRITE_INTERVAL) {
                 SetBestBlockIndex(pindex);
                 last_locator_write_time = current_time;
                 // No need to handle errors in Commit. See rationale above.
@@ -245,47 +282,98 @@ void BaseIndex::ThreadSync()
     }
 }
 
-bool BaseIndex::Commit()
+void BaseIndex::Commit()
 {
     // Don't commit anything if we haven't indexed any block yet
     // (this could happen if init is interrupted).
     bool ok = m_best_block_index != nullptr;
     if (ok) {
+        // Don't commit if the index best block is not an ancestor of the chainstate's last flushed
+        // block. Otherwise, after an unclean shutdown, the index could be
+        // persisted ahead of a chainstate it can no longer roll back to, which
+        // would corrupt indexes with state (e.g. coinstatsindex).
+        const CBlockIndex* index_tip = m_best_block_index.load();
+        const CBlockIndex* last_flushed = WITH_LOCK(::cs_main, return m_chainstate->GetLastFlushedBlock());
+        if (!last_flushed || last_flushed->GetAncestor(index_tip->nHeight) != index_tip) {
+            LogDebug(BCLog::COINDB, "Skipping commit, index is ahead of flushed chainstate (index height %d, last flush at height %d)\n",
+                    index_tip->nHeight, last_flushed ? last_flushed->nHeight : -1);
+            if (WritesEagerly()) {
+                CDBBatch batch(GetDB());
+                GetDB().WriteUncommittedTip(batch, index_tip->GetBlockHash());
+                GetDB().WriteBatch(batch);
+            }
+            return;
+        }
         CDBBatch batch(GetDB());
         ok = CustomCommit(batch);
         if (ok) {
             GetDB().WriteBestBlock(batch, GetLocator(*m_chain, m_best_block_index.load()->GetBlockHash()));
+            if (WritesEagerly()) GetDB().EraseUncommittedTip(batch);
             ok = GetDB().WriteBatch(batch);
         }
     }
     if (!ok) {
         LogError("%s: Failed to commit latest %s state\n", __func__, GetName());
-        return false;
+    }
+}
+
+void BaseIndex::WriteRewindLocator(CDBBatch& batch, const CBlockIndex* new_tip) const
+{
+    const auto above_new_tip{[&](const uint256& block_hash) {
+        const CBlockIndex* block{WITH_LOCK(::cs_main, return m_chainstate->m_blockman.LookupBlockIndex(block_hash))};
+        return block && block->nHeight > new_tip->nHeight && block->GetAncestor(new_tip->nHeight) == new_tip;
+    }};
+    // The committed tip was an ancestor of a flushed block when it was written, so it and new_tip below it are in
+    // the block index after a restart. A committed tip at or below new_tip needs no change.
+    if (const auto locator{GetDB().ReadBestBlock()}; !locator.IsNull() && above_new_tip(locator.vHave.front())) {
+        GetDB().WriteBestBlock(batch, GetLocator(*m_chain, new_tip->GetBlockHash()));
+    }
+    // Init() resumes from the uncommitted tip only while the block index has it, and then new_tip below it too.
+    if (const auto uncommitted_tip{GetDB().ReadUncommittedTip()}; uncommitted_tip && above_new_tip(*uncommitted_tip)) {
+        GetDB().WriteUncommittedTip(batch, new_tip->GetBlockHash());
+    }
+}
+
+const CBlockIndex* BaseIndex::ResumeBlock(const node::BlockManager& blockman, const CBlockIndex* locator_block) const
+{
+    AssertLockHeld(::cs_main);
+    // The entries up to the uncommitted tip are on disk, so resume from it while the block index has it above the
+    // locator. Commit() and rewinds keep the locator below it; one that isn't was left behind by an older binary.
+    const auto uncommitted_tip_hash{WritesEagerly() ? GetDB().ReadUncommittedTip() : std::nullopt};
+    const CBlockIndex* uncommitted_tip{uncommitted_tip_hash ? blockman.LookupBlockIndex(*uncommitted_tip_hash) : nullptr};
+    if (uncommitted_tip && (!locator_block || uncommitted_tip->GetAncestor(locator_block->nHeight) == locator_block)) {
+        return uncommitted_tip;
+    }
+    return locator_block;
+}
+
+bool BaseIndex::RewindBlockByBlock(const CBlockIndex* current_tip, const CBlockIndex* new_tip,
+                                   const std::function<bool(const CBlockIndex* pindex, CDBBatch& batch)>& rewind_block)
+{
+    for (const CBlockIndex* pindex = current_tip; pindex != new_tip; pindex = pindex->pprev) {
+        CDBBatch batch(GetDB());
+        if (!rewind_block(pindex, batch)) return false;
+        WriteRewindLocator(batch, pindex->pprev);
+        if (!GetDB().WriteBatch(batch)) return false;
     }
     return true;
 }
 
 bool BaseIndex::Rewind(const CBlockIndex* current_tip, const CBlockIndex* new_tip)
 {
-    assert(current_tip == m_best_block_index);
     assert(current_tip->GetAncestor(new_tip->nHeight) == new_tip);
 
     if (!CustomRewind({current_tip->GetBlockHash(), current_tip->nHeight}, {new_tip->GetBlockHash(), new_tip->nHeight})) {
         return false;
     }
 
-    // In the case of a reorg, ensure persisted block locator is not stale.
+    // Don't commit here - the committed index state must never be ahead of the
+    // flushed chainstate, otherwise unclean restarts would lead to index corruption.
     // Pruning has a minimum of 288 blocks-to-keep and getting the index
     // out of sync may be possible but a users fault.
     // In case we reorg beyond the pruned depth, ReadBlockFromDisk would
     // throw and lead to a graceful shutdown
     SetBestBlockIndex(new_tip);
-    if (!Commit()) {
-        // If commit fails, revert the best block index to avoid corruption.
-        SetBestBlockIndex(current_tip);
-        return false;
-    }
-
     return true;
 }
 
@@ -463,9 +551,9 @@ void BaseIndex::SetBestBlockIndex(const CBlockIndex* block)
 {
     assert(!m_chainstate->m_blockman.IsPruneMode() || AllowPrune());
 
-    if (AllowPrune() && block) {
+    if (AllowPrune()) {
         PruneLockInfo prune_lock;
-        prune_lock.height_first = block->nHeight;
+        prune_lock.height_first = block ? block->nHeight : 0;
         WITH_LOCK(::cs_main, m_chainstate->m_blockman.UpdatePruneLock(GetName(), prune_lock));
     }
 
diff --git a/src/index/base.h b/src/index/base.h
index db67924d9e75..d59e535f653e 100644
--- a/src/index/base.h
+++ b/src/index/base.h
@@ -12,11 +12,16 @@
 #include <validationinterface.h>
 
 #include <atomic>
+#include <functional>
+#include <optional>
 #include <string>
 
 class CBlock;
 class CBlockIndex;
 class Chainstate;
+namespace node {
+class BlockManager;
+} // namespace node
 namespace interfaces {
 class Chain;
 } // namespace interfaces
@@ -49,10 +54,16 @@ class BaseIndex : public CValidationInterface
            bool f_memory = false, bool f_wipe = false, bool f_obfuscate = false);
 
         /// Read block locator of the chain that the index is in sync with.
-        bool ReadBestBlock(CBlockLocator& locator) const;
+        /// Note, the returned locator will be empty if no record exists.
+        CBlockLocator ReadBestBlock() const;
 
         /// Write block locator of the chain that the index is in sync with.
         void WriteBestBlock(CDBBatch& batch, const CBlockLocator& locator);
+
+        /// The index tip that Commit() last skipped, if no commit has succeeded since. See WritesEagerly().
+        std::optional<uint256> ReadUncommittedTip() const;
+        void WriteUncommittedTip(CDBBatch& batch, const uint256& block_hash);
+        void EraseUncommittedTip(CDBBatch& batch);
     };
 
 private:
@@ -82,20 +93,23 @@ class BaseIndex : public CValidationInterface
     void ThreadSync();
 
     /// Write the current index state (eg. chain block locator and subclass-specific items) to disk.
-    ///
-    /// Recommendations for error handling:
-    /// If called on a successor of the previous committed best block in the index, the index can
-    /// continue processing without risk of corruption, though the index state will need to catch up
-    /// from further behind on reboot. If the new state is not a successor of the previous state (due
-    /// to a chain reorganization), the index must halt until Commit succeeds or else it could end up
-    /// getting corrupted.
-    bool Commit();
+    /// Will skip the commit if no block has been indexed yet or if the index's best block is
+    /// ahead of the chainstate's last flushed block. This avoids persisting state an unclean shutdown
+    /// could not roll back from. A later call commits when the chainstate has flushed far enough.
+    /// Indexes that write eagerly record a skipped tip instead, see WritesEagerly().
+    void Commit();
 
     /// Loop over disconnected blocks and call CustomRewind.
     bool Rewind(const CBlockIndex* current_tip, const CBlockIndex* new_tip);
 
     virtual bool AllowPrune() const = 0;
 
+    /// Whether CustomAppend() persists a block's entries right away. Commit() can't write the locator for a tip
+    /// above the last flush, so for these indexes it records that tip separately, and Init() resumes from it, or
+    /// fails if the block index lost it. Otherwise a restart would resume from the older locator and never rewind the
+    /// entries of blocks above it that are no longer on the active chain.
+    virtual bool WritesEagerly() const { return false; }
+
 protected:
     std::unique_ptr<interfaces::Chain> m_chain;
     Chainstate* m_chainstate{nullptr};
@@ -121,6 +135,22 @@ class BaseIndex : public CValidationInterface
     /// be an ancestor of the current best block.
     [[nodiscard]] virtual bool CustomRewind(const interfaces::BlockKey& current_tip, const interfaces::BlockKey& new_tip) { return true; }
 
+    /// For indexes whose CustomRewind() erases entries: if the committed locator is above new_tip on the same
+    /// branch, move it to new_tip. Commit() may not write new_tip yet (it can be ahead of the last flush), but
+    /// leaving the old locator above erased entries would make an unclean restart resume past them.
+    void WriteRewindLocator(CDBBatch& batch, const CBlockIndex* new_tip) const;
+
+    /// The block Init() resumes from, given the block of the committed locator: the uncommitted tip if the block
+    /// index has it above that block (see WritesEagerly()), otherwise the locator block itself.
+    const CBlockIndex* ResumeBlock(const node::BlockManager& blockman, const CBlockIndex* locator_block) const
+        EXCLUSIVE_LOCKS_REQUIRED(::cs_main);
+
+    /// For indexes that erase per block in CustomRewind(): walk from current_tip down to new_tip and write each
+    /// block's erasures, filled in by rewind_block, in one batch with WriteRewindLocator() for its parent. A rewind
+    /// interrupted between blocks then never leaves the committed locator above erased entries.
+    [[nodiscard]] bool RewindBlockByBlock(const CBlockIndex* current_tip, const CBlockIndex* new_tip,
+                                          const std::function<bool(const CBlockIndex* pindex, CDBBatch& batch)>& rewind_block);
+
     virtual DB& GetDB() const = 0;
 
     /// Get the name of the index for display in logs.
diff --git a/src/index/govcollateralindex.cpp b/src/index/govcollateralindex.cpp
index cab00c694e1c..64913943b3c9 100644
--- a/src/index/govcollateralindex.cpp
+++ b/src/index/govcollateralindex.cpp
@@ -117,7 +117,7 @@ bool GovCollateralIndex::CustomRewind(const interfaces::BlockKey& current_tip, c
             m_db->EraseCollateral(batch, txid);
         }
     }
-    m_db->WriteBestBlock(batch, GetLocator(new_tip_index));
+    WriteRewindLocator(batch, new_tip_index);
     return m_db->WriteBatch(batch);
 }
 
@@ -126,10 +126,18 @@ BaseIndex::DB& GovCollateralIndex::GetDB() const { return *m_db; }
 bool GovCollateralIndex::CanSync(Chainstate& chainstate) const
 {
     AssertLockHeld(::cs_main);
-    CBlockLocator locator;
+    const auto locator{m_db->ReadBestBlock()};
     const CBlockIndex* best_block{nullptr};
-    if (m_db->ReadBestBlock(locator) && !locator.IsNull()) {
+    const CBlockIndex* locator_block{nullptr};
+    if (!locator.IsNull()) {
         best_block = chainstate.FindForkInGlobalIndex(locator);
+        locator_block = chainstate.m_blockman.LookupBlockIndex(locator.vHave.front());
+    }
+    // Startup resumes from the uncommitted tip instead when there is one, and only needs the blocks above it. It
+    // fails without the locator's block, so the uncommitted tip can't stand in for that.
+    if (locator.IsNull() || locator_block) {
+        const CBlockIndex* resume_block{ResumeBlock(chainstate.m_blockman, locator_block)};
+        if (resume_block != locator_block) best_block = chainstate.m_chain.FindFork(resume_block);
     }
     for (const CBlockIndex* block{chainstate.m_chain.Tip()}; block != best_block; block = block->pprev) {
         if (!(block->nStatus & BLOCK_HAVE_DATA)) return false;
diff --git a/src/index/govcollateralindex.h b/src/index/govcollateralindex.h
index d7bfddb83159..b39b37b56406 100644
--- a/src/index/govcollateralindex.h
+++ b/src/index/govcollateralindex.h
@@ -31,6 +31,8 @@ class GovCollateralIndex final : public BaseIndex, public governance::Collateral
     bool AllowPrune() const override { return true; }
 
 protected:
+    bool WritesEagerly() const override { return true; }
+
     bool CustomInit(const std::optional<interfaces::BlockKey>& block) override;
 
     bool CustomAppend(const interfaces::BlockInfo& block) override;
diff --git a/src/index/spentindex.cpp b/src/index/spentindex.cpp
index 64c373a151ff..06af32143709 100644
--- a/src/index/spentindex.cpp
+++ b/src/index/spentindex.cpp
@@ -43,13 +43,11 @@ bool SpentIndex::DB::ReadSpentIndex(const CSpentIndexKey& key, CSpentIndexValue&
     return Read(std::make_pair(DB_SPENTINDEX, key), value);
 }
 
-bool SpentIndex::DB::EraseSpentIndex(const std::vector<CSpentIndexKey>& keys)
+void SpentIndex::DB::EraseSpentIndex(CDBBatch& batch, const std::vector<CSpentIndexKey>& keys)
 {
-    CDBBatch batch(*this);
     for (const auto& key : keys) {
         batch.Erase(std::make_pair(DB_SPENTINDEX, key));
     }
-    return CDBWrapper::WriteBatch(batch);
 }
 
 SpentIndex::SpentIndex(std::unique_ptr<interfaces::Chain> chain, size_t n_cache_size, bool f_memory, bool f_wipe) :
@@ -127,14 +125,14 @@ bool SpentIndex::CustomRewind(const interfaces::BlockKey& current_tip, const int
     assert(current_tip_index->GetAncestor(new_tip_index->nHeight) == new_tip_index);
 
     // Erase spent index entries for blocks being rewound
-    for (const CBlockIndex* pindex = current_tip_index; pindex != new_tip_index; pindex = pindex->pprev) {
+    return RewindBlockByBlock(current_tip_index, new_tip_index, [&](const CBlockIndex* pindex, CDBBatch& batch) {
         // Skip genesis block
-        if (pindex->nHeight == 0) continue;
+        if (pindex->nHeight == 0) return true;
 
         // Read block to get transactions
         CBlock block;
         if (!node::ReadBlockFromDisk(block, pindex, Params().GetConsensus())) {
-            LogError("%s: Failed to read block %s from disk during rewind\n", __func__,
+            LogError("%s: Failed to read block %s from disk during rewind\n", "CustomRewind",
                      pindex->GetBlockHash().ToString());
             return false;
         }
@@ -152,13 +150,9 @@ bool SpentIndex::CustomRewind(const interfaces::BlockKey& current_tip, const int
             }
         }
 
-        if (!keys_to_erase.empty() && !m_db->EraseSpentIndex(keys_to_erase)) {
-            LogError("%s: Failed to erase spent index during rewind\n", __func__);
-            return false;
-        }
-    }
-
-    return true;
+        m_db->EraseSpentIndex(batch, keys_to_erase);
+        return true;
+    });
 }
 
 BaseIndex::DB& SpentIndex::GetDB() const { return *m_db; }
diff --git a/src/index/spentindex.h b/src/index/spentindex.h
index 8a47e5babc8e..b7ba2122c274 100644
--- a/src/index/spentindex.h
+++ b/src/index/spentindex.h
@@ -42,7 +42,7 @@ class SpentIndex final : public BaseIndex
         bool ReadSpentIndex(const CSpentIndexKey& key, CSpentIndexValue& value);
 
         /// Erase spent index entries
-        bool EraseSpentIndex(const std::vector<CSpentIndexKey>& keys);
+        void EraseSpentIndex(CDBBatch& batch, const std::vector<CSpentIndexKey>& keys);
     };
 
     bool CustomAppend(const interfaces::BlockInfo& block) override;
@@ -53,6 +53,7 @@ class SpentIndex final : public BaseIndex
 
     /// SpentIndex cannot work with pruned nodes as it requires UTXO data
     bool AllowPrune() const override { return false; }
+    bool WritesEagerly() const override { return true; }
 
 public:
     /// Constructs a new SpentIndex.
diff --git a/src/index/timestampindex.cpp b/src/index/timestampindex.cpp
index 6f1d9af18952..dca38910eb02 100644
--- a/src/index/timestampindex.cpp
+++ b/src/index/timestampindex.cpp
@@ -41,9 +41,9 @@ void TimestampIndex::DB::ReadRange(uint32_t high, uint32_t low, std::vector<uint
     }
 }
 
-bool TimestampIndex::DB::EraseTimestampIndex(const CTimestampIndexKey& key)
+void TimestampIndex::DB::EraseTimestampIndex(CDBBatch& batch, const CTimestampIndexKey& key)
 {
-    return CDBWrapper::Erase(std::make_pair(DB_TIMESTAMPINDEX, key));
+    batch.Erase(std::make_pair(DB_TIMESTAMPINDEX, key));
 }
 
 TimestampIndex::TimestampIndex(std::unique_ptr<interfaces::Chain> chain, size_t n_cache_size, bool f_memory, bool f_wipe) :
@@ -72,20 +72,17 @@ bool TimestampIndex::CustomRewind(const interfaces::BlockKey& current_tip, const
     const CBlockIndex* new_tip_index = WITH_LOCK(cs_main, return m_chainstate->m_blockman.LookupBlockIndex(new_tip.hash));
     assert(current_tip_index->GetAncestor(new_tip_index->nHeight) == new_tip_index);
 
-    // Erase timestamp index entries for blocks being rewound
+    // Erase timestamp index entries for blocks being rewound, in one batch with the locator
+    CDBBatch batch(GetDB());
     for (const CBlockIndex* pindex = current_tip_index; pindex != new_tip_index; pindex = pindex->pprev) {
         // Skip genesis block
         if (pindex->nHeight == 0) continue;
 
-        CTimestampIndexKey key(pindex->nTime, pindex->GetBlockHash());
-        if (!m_db->EraseTimestampIndex(key)) {
-            LogError("%s: Failed to erase timestamp index for block %s during rewind\n", __func__,
-                     pindex->GetBlockHash().ToString());
-            return false;
-        }
+        m_db->EraseTimestampIndex(batch, CTimestampIndexKey(pindex->nTime, pindex->GetBlockHash()));
     }
 
-    return true;
+    WriteRewindLocator(batch, new_tip_index);
+    return GetDB().WriteBatch(batch);
 }
 
 BaseIndex::DB& TimestampIndex::GetDB() const { return *m_db; }
diff --git a/src/index/timestampindex.h b/src/index/timestampindex.h
index d24e58ebcd0b..0317c89db51c 100644
--- a/src/index/timestampindex.h
+++ b/src/index/timestampindex.h
@@ -37,7 +37,7 @@ class TimestampIndex final : public BaseIndex
         void ReadRange(uint32_t high, uint32_t low, std::vector<uint256>& hashes);
 
         /// Erase timestamp index entry
-        bool EraseTimestampIndex(const CTimestampIndexKey& key);
+        void EraseTimestampIndex(CDBBatch& batch, const CTimestampIndexKey& key);
     };
 
     bool CustomAppend(const interfaces::BlockInfo& block) override;
@@ -49,6 +49,7 @@ class TimestampIndex final : public BaseIndex
 
     /// TimestampIndex works with pruned nodes since it only stores block metadata
     bool AllowPrune() const override { return true; }
+    bool WritesEagerly() const override { return true; }
 
 public:
     /// Constructs a new TimestampIndex.
diff --git a/src/test/baseindex_tests.cpp b/src/test/baseindex_tests.cpp
new file mode 100644
index 000000000000..bf3117554bf4
--- /dev/null
+++ b/src/test/baseindex_tests.cpp
@@ -0,0 +1,328 @@
+// Copyright (c) 2020-present The Bitcoin Core developers
+// Distributed under the MIT software license, see the accompanying
+// file COPYING or http://www.opensource.org/licenses/mit-license.php.
+
+#include <chain.h>
+#include <consensus/validation.h>
+#include <index/coinstatsindex.h>
+#include <interfaces/chain.h>
+#include <node/blockstorage.h>
+#include <script/script.h>
+#include <test/util/index.h>
+#include <test/util/setup_common.h>
+#include <util/check.h>
+#include <util/system.h>
+#include <validation.h>
+#include <validationinterface.h>
+
+#include <boost/test/unit_test.hpp>
+
+#include <memory>
+#include <optional>
+#include <vector>
+
+namespace {
+//! A minimal index that, like Dash's address and spent indexes, keeps one entry per block and erases the entries of
+//! rewound blocks in CustomRewind() block by block. The rewind is exposed, and can stop after a given block, so a test
+//! can leave the on-disk state that an unclean shutdown in the middle of a reorg would leave, without having to time
+//! an actual crash.
+class ErasingIndex final : public BaseIndex
+{
+    const std::unique_ptr<BaseIndex::DB> m_db;
+    const CBlockIndex* m_stop_after{nullptr};
+
+public:
+    explicit ErasingIndex(std::unique_ptr<interfaces::Chain> chain)
+        : BaseIndex(std::move(chain), "erasing test index"),
+          m_db{std::make_unique<BaseIndex::DB>(gArgs.GetDataDirNet() / "indexes" / "erasingtest", /*n_cache_size=*/1 << 20)}
+    {
+    }
+    ~ErasingIndex() override
+    {
+        Interrupt();
+        Stop();
+    }
+
+    bool Indexed(const CBlockIndex* block) const { return Indexed(block->GetBlockHash()); }
+    bool Indexed(const uint256& block_hash) const { return m_db->Exists(std::make_pair(uint8_t{'e'}, block_hash)); }
+    //! Write the entry CustomAppend() writes, for a block the block index doesn't have
+    void WriteEntry(const uint256& block_hash)
+    {
+        BOOST_REQUIRE(m_db->Write(std::make_pair(uint8_t{'e'}, block_hash), true));
+    }
+    //! Rewind, or with stop_after set, stop as a crash would once that block's batch is written
+    bool RewindTo(const CBlockIndex* current_tip, const CBlockIndex* new_tip, const CBlockIndex* stop_after = nullptr)
+    {
+        m_stop_after = stop_after;
+        const bool ok{CustomRewind({current_tip->GetBlockHash(), current_tip->nHeight}, {new_tip->GetBlockHash(), new_tip->nHeight})};
+        m_stop_after = nullptr;
+        return ok;
+    }
+    std::optional<uint256> UncommittedTip() const { return m_db->ReadUncommittedTip(); }
+    void SetUncommittedTip(const uint256& block_hash)
+    {
+        CDBBatch batch(*m_db);
+        m_db->WriteUncommittedTip(batch, block_hash);
+        m_db->WriteBatch(batch);
+    }
+    uint256 CommittedTip() const
+    {
+        const auto locator{m_db->ReadBestBlock()};
+        BOOST_REQUIRE(!locator.IsNull());
+        return locator.vHave.front();
+    }
+
+protected:
+    bool CustomAppend(const interfaces::BlockInfo& block) override { return m_db->Write(std::make_pair(uint8_t{'e'}, block.hash), true); }
+    bool CustomRewind(const interfaces::BlockKey& current_tip, const interfaces::BlockKey& new_tip) override
+    {
+        const CBlockIndex* current_tip_index{WITH_LOCK(::cs_main, return m_chainstate->m_blockman.LookupBlockIndex(current_tip.hash))};
+        const CBlockIndex* new_tip_index{WITH_LOCK(::cs_main, return m_chainstate->m_blockman.LookupBlockIndex(new_tip.hash))};
+        return RewindBlockByBlock(current_tip_index, new_tip_index, [&](const CBlockIndex* pindex, CDBBatch& batch) {
+            if (m_stop_after && pindex == m_stop_after->pprev) return false;
+            batch.Erase(std::make_pair(uint8_t{'e'}, pindex->GetBlockHash()));
+            return true;
+        });
+    }
+    BaseIndex::DB& GetDB() const override { return *m_db; }
+    bool AllowPrune() const override { return true; }
+    bool WritesEagerly() const override { return true; }
+};
+
+const CBlockIndex* AtHeight(ChainstateManager& chainman, int height)
+{
+    return WITH_LOCK(::cs_main, return chainman.ActiveChain()[height]);
+}
+
+//! Make `height` the chainstate's last flushed block while the tip stays above it: flush with the blocks above
+//! disconnected, then connect them again without a flush.
+void LowerLastFlushedBlock(ChainstateManager& chainman, int height)
+{
+    Chainstate& chainstate{chainman.ActiveChainstate()};
+    CBlockIndex* first_disconnected{WITH_LOCK(::cs_main, return chainman.ActiveChain()[height + 1])};
+    BlockValidationState state;
+    BOOST_REQUIRE(chainstate.InvalidateBlock(state, first_disconnected));
+    chainstate.ForceFlushStateToDisk();
+    WITH_LOCK(::cs_main, chainstate.ResetBlockFailureFlags(first_disconnected));
+    BOOST_REQUIRE(chainstate.ActivateBestChain(state));
+    BOOST_REQUIRE_EQUAL(WITH_LOCK(::cs_main, return chainstate.GetLastFlushedBlock()->nHeight), height);
+}
+} // namespace
+
+// Tests of generic BaseIndex functionality that is independent of which
+// concrete index is being used. CoinStatsIndex is used here merely as a
+// convenient instantiation of BaseIndex.
+BOOST_AUTO_TEST_SUITE(baseindex_tests)
+
+// Test that the index does not commit ahead of the chainstate's last
+// flushed block. If it did, a subsequent unclean shutdown would corrupt
+// the index, because during reverting it would require blocks that were
+// never flushed to disk.
+BOOST_FIXTURE_TEST_CASE(baseindex_no_commit_ahead_of_flush, TestChain100Setup)
+{
+    Chainstate& chainstate = Assert(m_node.chainman)->ActiveChainstate();
+    auto sync_index = [&](bool do_flush, int expected_sync_height, int expected_commit_height) {
+        {
+            CoinStatsIndex index{interfaces::MakeChain(m_node), /*n_cache_size=*/1 << 20};
+            BOOST_REQUIRE(index.Start());
+            IndexWaitSynced(index);
+            if (do_flush) {
+                chainstate.ForceFlushStateToDisk();
+                SyncWithValidationInterfaceQueue();
+            }
+            BOOST_CHECK_EQUAL(index.GetSummary().best_block_height, expected_sync_height);
+            index.Stop();
+        }
+        // Reload index to see which block data was actually committed. Init() and Sync() are not
+        // callable on their own in Dash, so hold back the sync thread while the loaded best block is read.
+        node::g_indexes_ready_to_sync = false;
+        {
+            CoinStatsIndex index{interfaces::MakeChain(m_node), /*n_cache_size=*/1 << 20};
+            BOOST_REQUIRE(index.Start());
+            BOOST_CHECK_EQUAL(index.GetSummary().best_block_height, expected_commit_height);
+            index.Interrupt();
+            index.Stop();
+        }
+        node::g_indexes_ready_to_sync = true;
+    };
+
+    // Part 1: Sync, then "crash" (stop without flushing). Models a node that
+    // started up, had its index catch up, but never flushed before going down.
+    // The end-of-sync Commit() runs at chain tip (height 100) but
+    // m_last_flushed_block is null, so it is skipped.
+    sync_index(false, 100, 0);
+
+    // Part 2: Restart cleanly. Sync, force a chainstate flush, and drain the
+    // validation queue so the index's ChainStateFlushed callback runs.
+    // Now m_last_flushed_block == tip == 100 and the index can commit.
+    sync_index(true, 100, 100);
+
+    // Part 3: Connect a new block on the chain without flushing
+    // (m_last_flushed_block stays at 100). For a real node this would happen
+    // in parallel with Sync(). Here we do it before Sync() to make the race
+    // state deterministic.
+    CreateAndProcessBlock({}, CScript() << OP_TRUE);
+    sync_index(false, 101, 100);
+}
+
+// A rewind persists its erasures right away. If the node then stops before the rewound tip is flushed and the
+// rewound blocks are back on the active chain, the next start must index them again instead of resuming above them.
+BOOST_FIXTURE_TEST_CASE(restart_after_rewind_reindexes_erased_blocks, TestChain100Setup)
+{
+    ChainstateManager& chainman{*Assert(m_node.chainman)};
+    {
+        ErasingIndex index{interfaces::MakeChain(m_node)};
+        BOOST_REQUIRE(index.Start());
+        IndexWaitSynced(index);
+        chainman.ActiveChainstate().ForceFlushStateToDisk();
+        SyncWithValidationInterfaceQueue();
+        index.Stop();
+    }
+    // The rewind target (97) is now above the last flush (95), so Commit() cannot persist it
+    LowerLastFlushedBlock(chainman, 95);
+    const CBlockIndex* tip{AtHeight(chainman, 100)};
+
+    node::g_indexes_ready_to_sync = false;
+    {
+        ErasingIndex index{interfaces::MakeChain(m_node)};
+        BOOST_REQUIRE(index.Start());
+        BOOST_CHECK(index.CommittedTip() == tip->GetBlockHash());
+        BOOST_REQUIRE(index.RewindTo(tip, AtHeight(chainman, 97)));
+        BOOST_CHECK(!index.Indexed(tip));
+        BOOST_CHECK(index.CommittedTip() == AtHeight(chainman, 97)->GetBlockHash());
+        index.Interrupt();
+        index.Stop();
+    }
+    node::g_indexes_ready_to_sync = true;
+
+    // The rewound blocks are still the active chain, as after a restart in which their branch wins again
+    ErasingIndex index{interfaces::MakeChain(m_node)};
+    BOOST_REQUIRE(index.Start());
+    IndexWaitSynced(index);
+    for (int height{98}; height <= 100; ++height) {
+        BOOST_CHECK_MESSAGE(index.Indexed(AtHeight(chainman, height)), "block " << height << " was not indexed again");
+    }
+    index.Stop();
+}
+
+// Each block's erasures are written in one batch with a locator at its parent. A node that stops in the middle of a
+// rewind then resumes from the last block whose entries are still there, and indexes the erased ones again.
+BOOST_FIXTURE_TEST_CASE(interrupted_rewind_keeps_locator_below_erased_entries, TestChain100Setup)
+{
+    ChainstateManager& chainman{*Assert(m_node.chainman)};
+    {
+        ErasingIndex index{interfaces::MakeChain(m_node)};
+        BOOST_REQUIRE(index.Start());
+        IndexWaitSynced(index);
+        chainman.ActiveChainstate().ForceFlushStateToDisk();
+        SyncWithValidationInterfaceQueue();
+        index.Stop();
+    }
+    const CBlockIndex* tip{AtHeight(chainman, 100)};
+
+    node::g_indexes_ready_to_sync = false;
+    {
+        ErasingIndex index{interfaces::MakeChain(m_node)};
+        BOOST_REQUIRE(index.Start());
+        BOOST_CHECK(index.CommittedTip() == tip->GetBlockHash());
+        BOOST_CHECK(!index.RewindTo(tip, AtHeight(chainman, 97), /*stop_after=*/tip));
+        BOOST_CHECK(!index.Indexed(tip));
+        BOOST_CHECK(index.Indexed(AtHeight(chainman, 99)));
+        BOOST_CHECK(index.CommittedTip() == AtHeight(chainman, 99)->GetBlockHash());
+        index.Interrupt();
+        index.Stop();
+    }
+    node::g_indexes_ready_to_sync = true;
+
+    ErasingIndex index{interfaces::MakeChain(m_node)};
+    BOOST_REQUIRE(index.Start());
+    IndexWaitSynced(index);
+    BOOST_CHECK_MESSAGE(index.Indexed(tip), "block 100 was not indexed again");
+    index.Stop();
+}
+
+// A sync that ends above the last flush can't commit its locator, but its entries are on disk. If those blocks leave
+// the active chain while the index is off, the next start must rewind them from the tip the sync reached.
+BOOST_FIXTURE_TEST_CASE(restart_rewinds_blocks_synced_above_flush, TestChain100Setup)
+{
+    ChainstateManager& chainman{*Assert(m_node.chainman)};
+    LowerLastFlushedBlock(chainman, 97);
+    const std::vector<const CBlockIndex*> orphaned{AtHeight(chainman, 98), AtHeight(chainman, 99), AtHeight(chainman, 100)};
+    {
+        ErasingIndex index{interfaces::MakeChain(m_node)};
+        BOOST_REQUIRE(index.Start());
+        IndexWaitSynced(index);
+        BOOST_CHECK(index.UncommittedTip() == orphaned.back()->GetBlockHash());
+        index.Stop();
+    }
+
+    // A rewind that stops after its first block moves the uncommitted tip down with it, so the next start, with the
+    // rewound block still on the active chain, indexes it again
+    node::g_indexes_ready_to_sync = false;
+    {
+        ErasingIndex index{interfaces::MakeChain(m_node)};
+        BOOST_REQUIRE(index.Start());
+        BOOST_CHECK(!index.RewindTo(orphaned.back(), AtHeight(chainman, 97), /*stop_after=*/orphaned.back()));
+        BOOST_CHECK(index.UncommittedTip() == orphaned[1]->GetBlockHash());
+        index.Interrupt();
+        index.Stop();
+    }
+    node::g_indexes_ready_to_sync = true;
+    {
+        ErasingIndex index{interfaces::MakeChain(m_node)};
+        BOOST_REQUIRE(index.Start());
+        IndexWaitSynced(index);
+        BOOST_CHECK(index.Indexed(orphaned.back()));
+        index.Stop();
+    }
+
+    // The reorged-away blocks stay in the block index, as after a periodic write before an unclean stop
+    BlockValidationState state;
+    BOOST_REQUIRE(chainman.ActiveChainstate().InvalidateBlock(state, WITH_LOCK(::cs_main, return chainman.ActiveChain()[98])));
+    for (int i{0}; i < 4; ++i) CreateAndProcessBlock({}, CScript() << OP_TRUE);
+
+    {
+        ErasingIndex index{interfaces::MakeChain(m_node)};
+        BOOST_REQUIRE(index.Start());
+        IndexWaitSynced(index);
+        for (const CBlockIndex* block : orphaned) {
+            BOOST_CHECK_MESSAGE(!index.Indexed(block), "orphaned block " << block->nHeight << " is still indexed");
+        }
+        for (int height{98}; height <= 101; ++height) {
+            BOOST_CHECK(index.Indexed(AtHeight(chainman, height)));
+        }
+        chainman.ActiveChainstate().ForceFlushStateToDisk();
+        SyncWithValidationInterfaceQueue();
+        BOOST_CHECK(!index.UncommittedTip());
+        index.Stop();
+    }
+
+    // An uncommitted tip that isn't above the locator was left behind by an older binary: it is dropped and the index
+    // starts from the locator
+    node::g_indexes_ready_to_sync = false;
+    {
+        ErasingIndex index{interfaces::MakeChain(m_node)};
+        index.SetUncommittedTip(orphaned.back()->GetBlockHash());
+        BOOST_REQUIRE(index.Start());
+        BOOST_CHECK_EQUAL(index.GetSummary().best_block_height, 101);
+        BOOST_CHECK(!index.UncommittedTip());
+        index.Interrupt();
+        index.Stop();
+    }
+
+    // An unclean stop can lose blocks the index already wrote entries for from the block index. Startup can't rewind
+    // those entries, so it must fail rather than resume from the locator with them in place.
+    const CBlock lost_block{CreateBlock({}, CScript() << OP_TRUE, chainman.ActiveChainstate())};
+    BOOST_REQUIRE(!WITH_LOCK(::cs_main, return chainman.m_blockman.LookupBlockIndex(lost_block.GetHash())));
+    {
+        ErasingIndex index{interfaces::MakeChain(m_node)};
+        index.WriteEntry(lost_block.GetHash());
+        index.SetUncommittedTip(lost_block.GetHash());
+        BOOST_CHECK(!index.Start());
+        BOOST_CHECK(index.UncommittedTip() == lost_block.GetHash());
+        BOOST_CHECK(index.Indexed(lost_block.GetHash()));
+    }
+    node::g_indexes_ready_to_sync = true;
+}
+
+BOOST_AUTO_TEST_SUITE_END()
diff --git a/src/test/blockfilter_index_tests.cpp b/src/test/blockfilter_index_tests.cpp
index 1a8612eb1c64..ba5db2a09f0c 100644
--- a/src/test/blockfilter_index_tests.cpp
+++ b/src/test/blockfilter_index_tests.cpp
@@ -17,6 +17,7 @@
 #include <validation.h>
 
 #include <boost/test/unit_test.hpp>
+#include <future>
 
 using node::BlockAssembler;
 using node::CBlockTemplate;
@@ -304,4 +305,80 @@ BOOST_FIXTURE_TEST_CASE(blockfilter_index_init_destroy, BasicTestingSetup)
     BOOST_CHECK(filter_index == nullptr);
 }
 
+class IndexReorgCrash : public BaseIndex
+{
+private:
+    std::unique_ptr<BaseIndex::DB> m_db;
+    std::shared_future<void> m_blocker;
+    int m_blocking_height;
+
+public:
+    explicit IndexReorgCrash(std::unique_ptr<interfaces::Chain> chain, std::shared_future<void> blocker,
+                             int blocking_height) : BaseIndex(std::move(chain), "test index"), m_blocker(blocker),
+                                                    m_blocking_height(blocking_height)
+    {
+        const fs::path path = gArgs.GetDataDirNet() / "index";
+        fs::create_directories(path);
+        m_db = std::make_unique<BaseIndex::DB>(path / "db", /*n_cache_size=*/0, /*f_memory=*/true, /*f_wipe=*/false);
+    }
+
+    bool AllowPrune() const override { return false; }
+    BaseIndex::DB& GetDB() const override { return *m_db; }
+
+    bool CustomAppend(const interfaces::BlockInfo& block) override
+    {
+        // Simulate a delay so new blocks can get connected during the initial sync
+        if (block.height == m_blocking_height) m_blocker.wait();
+
+        // Move mock time forward so the best index gets updated only when we are not at the blocking height
+        if (block.height == m_blocking_height - 1 || block.height > m_blocking_height) {
+            SetMockTime(GetTime<std::chrono::seconds>() + 31s);
+        }
+
+        return true;
+    }
+};
+
+BOOST_FIXTURE_TEST_CASE(index_reorg_crash, BuildChainTestingSetup)
+{
+    // Enable mock time
+    SetMockTime(GetTime<std::chrono::minutes>());
+
+    std::promise<void> promise;
+    std::shared_future<void> blocker(promise.get_future());
+    int blocking_height = WITH_LOCK(cs_main, return m_node.chainman->ActiveChain().Tip()->nHeight);
+
+    IndexReorgCrash index(interfaces::MakeChain(m_node), blocker, blocking_height);
+    BOOST_REQUIRE(index.Start());
+
+    auto func_wait_until = [&](int height, std::chrono::milliseconds timeout) {
+        auto deadline = std::chrono::steady_clock::now() + timeout;
+        while (index.GetSummary().best_block_height < height) {
+            if (std::chrono::steady_clock::now() > deadline) {
+                BOOST_FAIL(strprintf("Timeout waiting for index height %d (current: %d)", height, index.GetSummary().best_block_height));
+                return;
+            }
+            std::this_thread::sleep_for(100ms);
+        }
+    };
+
+    // Wait until the index is one block before the fork point
+    func_wait_until(blocking_height - 1, /*timeout=*/5s);
+
+    // Create a fork to trigger the reorg
+    std::vector<std::shared_ptr<CBlock>> fork;
+    const CBlockIndex* prev_tip = WITH_LOCK(cs_main, return m_node.chainman->ActiveChain().Tip()->pprev);
+    BOOST_REQUIRE(BuildChain(prev_tip, GetScriptForDestination(PKHash(GenerateRandomKey().GetPubKey())), 3, fork));
+
+    for (const auto& block : fork) {
+        BOOST_REQUIRE(m_node.chainman->ProcessNewBlock(block, /*force_processing=*/true, nullptr));
+    }
+
+    // Unblock the index thread so it can process the reorg
+    promise.set_value();
+    // Wait for the index to reach the new tip
+    func_wait_until(blocking_height + 2, 5s);
+    index.Stop();
+}
+
 BOOST_AUTO_TEST_SUITE_END()
diff --git a/src/test/governance_collateral_tests.cpp b/src/test/governance_collateral_tests.cpp
index 74aa3c4a8382..3e6c30f71592 100644
--- a/src/test/governance_collateral_tests.cpp
+++ b/src/test/governance_collateral_tests.cpp
@@ -3,6 +3,7 @@
 // file COPYING or http://www.opensource.org/licenses/mit-license.php.
 
 #include <consensus/validation.h>
+#include <dbwrapper.h>
 #include <governance/collateral.h>
 #include <governance/object.h>
 #include <index/govcollateralindex.h>
@@ -204,4 +205,42 @@ BOOST_FIXTURE_TEST_CASE(proposal_collateral_is_checked_against_the_index, Collat
     BOOST_CHECK(error.find("Couldn't find opReturn") == 0);
 }
 
+// Startup resumes from the tip a skipped commit recorded, so the sync check must only need the blocks above it
+BOOST_FIXTURE_TEST_CASE(sync_check_needs_only_blocks_above_the_resume_point, TestChain100Setup)
+{
+    Chainstate& chainstate{Assert(m_node.chainman)->ActiveChainstate()};
+    // Nothing has been flushed, so the end-of-sync commit is skipped and only the uncommitted tip (100) is recorded
+    BOOST_REQUIRE(WITH_LOCK(::cs_main, return !chainstate.GetLastFlushedBlock()));
+    {
+        GovCollateralIndex synced_index{interfaces::MakeChain(m_node), /*n_cache_size=*/1 << 20};
+        BOOST_REQUIRE(synced_index.Start());
+        IndexWaitSynced(synced_index);
+        synced_index.Stop();
+    }
+    for (int i = 0; i < 3; ++i) {
+        CreateAndProcessBlock({}, GetScriptForRawPubKey(coinbaseKey.GetPubKey()));
+    }
+    const auto can_sync_without_data_at = [&](int height) {
+        GovCollateralIndex index{interfaces::MakeChain(m_node), /*n_cache_size=*/1 << 20};
+        LOCK(::cs_main);
+        CBlockIndex* pruned{chainstate.m_chain[height]};
+        pruned->nStatus &= ~BLOCK_HAVE_DATA;
+        const bool can_sync{index.CanSync(chainstate)};
+        pruned->nStatus |= BLOCK_HAVE_DATA;
+        return can_sync;
+    };
+    BOOST_CHECK(can_sync_without_data_at(50));
+    BOOST_CHECK(!can_sync_without_data_at(102));
+
+    // Startup fails when the block index lacks the locator's block, so the sync check must not rely on the
+    // uncommitted tip then
+    {
+        CDBWrapper db{DBParams{.path = m_args.GetDataDirNet() / "indexes" / "govcollateralindex", .cache_bytes = 1 << 20}};
+        CDBBatch batch{db};
+        batch.Write(uint8_t{'B'}, CBlockLocator{{uint256::ONE}});
+        BOOST_REQUIRE(db.WriteBatch(batch));
+    }
+    BOOST_CHECK(!can_sync_without_data_at(50));
+}
+
 BOOST_AUTO_TEST_SUITE_END()
diff --git a/src/validation.cpp b/src/validation.cpp
index cb6c95dc8e03..cafb278dd56d 100644
--- a/src/validation.cpp
+++ b/src/validation.cpp
@@ -3317,6 +3317,7 @@ bool Chainstate::FlushStateToDisk(
                 // Flush the chainstate (which may refer to block index entries).
                 if (!CoinsTip().Flush())
                     return AbortNode(state, "Failed to write to coin database");
+                m_last_flushed_block = m_blockman.LookupBlockIndex(CoinsTip().GetBestBlock());
             }
             {
                 LOG_TIME_SECONDS("write evodb cache to disk");
@@ -3335,9 +3336,8 @@ bool Chainstate::FlushStateToDisk(
         }
     }
     if (full_flush_completed && this == &m_chainman.ActiveChainstate()) {
-        // Update best block in wallet (so we can detect restored wallets).
         // TODO(assumeutxo): upstream tags this notification with ChainstateRole instead of suppressing; adopt when backporting index/wallet assumeutxo support.
-        GetMainSignals().ChainStateFlushed(m_chain.GetLocator());
+        GetMainSignals().ChainStateFlushed(GetLocator(m_last_flushed_block));
     }
     } catch (const std::runtime_error& e) {
         return AbortNode(state, std::string("System error while flushing: ") + e.what());
@@ -5232,6 +5232,7 @@ bool Chainstate::LoadChainTip()
         return false;
     }
     m_chain.SetTip(*pindex);
+    m_last_flushed_block = pindex;
     PruneBlockIndexCandidates();
 
     tip = m_chain.Tip();
diff --git a/src/validation.h b/src/validation.h
index 255451d0d926..c51a7d710bcd 100644
--- a/src/validation.h
+++ b/src/validation.h
@@ -777,6 +777,9 @@ class Chainstate
 
     std::string ToString() EXCLUSIVE_LOCKS_REQUIRED(::cs_main);
 
+    //! Get the last block that was flushed to disk.
+    const CBlockIndex* GetLastFlushedBlock() const EXCLUSIVE_LOCKS_REQUIRED(::cs_main) { return m_last_flushed_block; }
+
     //! Indirection necessary to make lock annotations work with an optional mempool.
     RecursiveMutex* MempoolMutex() const LOCK_RETURNED(m_mempool->cs)
     {
@@ -825,6 +828,7 @@ class Chainstate
 
     SteadyClock::time_point m_last_write{};
     SteadyClock::time_point m_last_flush{};
+    const CBlockIndex* m_last_flushed_block GUARDED_BY(::cs_main){nullptr};
 
     /**
      * In case of an invalid snapshot, rename the coins leveldb directory so
diff --git a/src/wallet/interfaces.cpp b/src/wallet/interfaces.cpp
index f03fd57b3d22..1d8b92a35662 100644
--- a/src/wallet/interfaces.cpp
+++ b/src/wallet/interfaces.cpp
@@ -966,7 +966,7 @@ class WalletLoaderImpl : public WalletLoader
         m_context.args = &args;
         m_context.node_context = &node_context;
     }
-    ~WalletLoaderImpl() override { UnloadWallets(m_context); }
+    ~WalletLoaderImpl() override { stop(); }
 
     //! ChainClient methods
     void registerRpcs() override
@@ -977,7 +977,7 @@ class WalletLoaderImpl : public WalletLoader
     bool load() override { return LoadWallets(m_context); }
     void start(CScheduler& scheduler) override { return StartWallets(m_context, scheduler); }
     void flush() override { return FlushWallets(m_context); }
-    void stop() override { return StopWallets(m_context); }
+    void stop() override { return UnloadWallets(m_context); }
     void setMockTime(int64_t time) override { return SetMockTime(time); }
 
     //! WalletLoader methods
diff --git a/src/wallet/load.cpp b/src/wallet/load.cpp
index b3cd26909bbf..317fa2de6988 100644
--- a/src/wallet/load.cpp
+++ b/src/wallet/load.cpp
@@ -169,13 +169,6 @@ void FlushWallets(WalletContext& context)
     }
 }
 
-void StopWallets(WalletContext& context)
-{
-    for (const std::shared_ptr<CWallet>& pwallet : GetWallets(context)) {
-        pwallet->Close();
-    }
-}
-
 void UnloadWallets(WalletContext& context)
 {
     auto wallets = GetWallets(context);
diff --git a/src/wallet/load.h b/src/wallet/load.h
index 88973e428c63..c4d70a394a9b 100644
--- a/src/wallet/load.h
+++ b/src/wallet/load.h
@@ -35,10 +35,6 @@ void StartWallets(WalletContext& context, CScheduler& scheduler);
 //! Flush all wallets in preparation for shutdown.
 void FlushWallets(WalletContext& context);
 
-//! Stop all wallets. Wallets will be flushed first.
-void StopWallets(WalletContext& context);
-
-//! Close all wallets.
 void UnloadWallets(WalletContext& context);
 } // namespace wallet
 
diff --git a/src/wallet/test/wallet_tests.cpp b/src/wallet/test/wallet_tests.cpp
index 20db3c28a0c5..dfec1db4d420 100644
--- a/src/wallet/test/wallet_tests.cpp
+++ b/src/wallet/test/wallet_tests.cpp
@@ -169,8 +169,8 @@ BOOST_FIXTURE_TEST_CASE(scan_for_wallet_transactions, TestChain100Setup)
 
         {
             CBlockLocator locator;
-            BOOST_CHECK(!WalletBatch{wallet.GetDatabase()}.ReadBestBlock(locator));
-            BOOST_CHECK(locator.IsNull());
+            BOOST_CHECK(WalletBatch{wallet.GetDatabase()}.ReadBestBlock(locator));
+            BOOST_CHECK(!locator.IsNull() && locator.vHave.front() == newTip->GetBlockHash());
         }
 
         CWallet::ScanResult result = wallet.ScanForWalletTransactions(/*start_block=*/oldTip->GetBlockHash(), /*start_height=*/oldTip->nHeight, /*max_height=*/{}, reserver, /*fUpdate=*/false, /*save_progress=*/true);
@@ -183,7 +183,7 @@ BOOST_FIXTURE_TEST_CASE(scan_for_wallet_transactions, TestChain100Setup)
         {
             CBlockLocator locator;
             BOOST_CHECK(WalletBatch{wallet.GetDatabase()}.ReadBestBlock(locator));
-            BOOST_CHECK(!locator.IsNull());
+            BOOST_CHECK(!locator.IsNull() && locator.vHave.front() == newTip->GetBlockHash());
         }
     }
 
diff --git a/src/wallet/wallet.cpp b/src/wallet/wallet.cpp
index e1e3c7736dfb..6e1e581e1f98 100644
--- a/src/wallet/wallet.cpp
+++ b/src/wallet/wallet.cpp
@@ -148,6 +148,7 @@ bool RemoveWallet(WalletContext& context, const std::shared_ptr<CWallet>& wallet
 
     interfaces::Chain& chain = wallet->chain();
     std::string name = wallet->GetName();
+    WITH_LOCK(wallet->cs_wallet, wallet->WriteBestBlock());
 
     // Unregister with the validation interface which also drops shared pointers.
     wallet->m_chain_notifications_handler.reset();
@@ -671,15 +672,20 @@ bool CWallet::ChangeWalletPassphrase(const SecureString& strOldWalletPassphrase,
     return false;
 }
 
-void CWallet::chainStateFlushed(const CBlockLocator& loc)
+void CWallet::SetLastBlockProcessedInMem(int block_height, uint256 block_hash)
 {
-    // Don't update the best block until the chain is attached so that in case of a shutdown,
-    // the rescan will be restarted at next startup.
-    if (m_attaching_chain) {
-        return;
-    }
-    WalletBatch batch(GetDatabase());
-    batch.WriteBestBlock(loc);
+    AssertLockHeld(cs_wallet);
+
+    m_last_block_processed = block_hash;
+    m_last_block_processed_height = block_height;
+}
+
+void CWallet::SetLastBlockProcessed(int block_height, uint256 block_hash)
+{
+    AssertLockHeld(cs_wallet);
+
+    SetLastBlockProcessedInMem(block_height, block_hash);
+    WriteBestBlock();
 }
 
 void CWallet::SetMinVersion(enum WalletFeature nVersion, WalletBatch* batch_in)
@@ -1535,10 +1541,10 @@ void CWallet::RecursiveUpdateTxState(const uint256& tx_hash, const TryUpdatingSt
     fAnonymizableTallyCachedNonDenom = false;
 }
 
-void CWallet::SyncTransaction(const CTransactionRef& ptx, const SyncTxState& state, WalletBatch& batch, bool update_tx, bool rescanning_old_block)
+bool CWallet::SyncTransaction(const CTransactionRef& ptx, const SyncTxState& state, WalletBatch& batch, bool update_tx, bool rescanning_old_block)
 {
     if (!AddToWalletIfInvolvingMe(ptx, state, batch, update_tx, rescanning_old_block))
-        return; // Not one of ours
+        return false; // Not one of ours
 
     // If a transaction changes 'conflicted' state, that changes the balance
     // available of the outputs it spends. So force those to be
@@ -1547,6 +1553,7 @@ void CWallet::SyncTransaction(const CTransactionRef& ptx, const SyncTxState& sta
 
     fAnonymizableTallyCached = false;
     fAnonymizableTallyCachedNonDenom = false;
+    return true;
 }
 
 void CWallet::transactionAddedToMempool(const CTransactionRef& tx, int64_t nAcceptTime) {
@@ -1611,8 +1618,9 @@ void CWallet::blockConnected(const interfaces::BlockInfo& block)
     assert(block.data);
     LOCK(cs_wallet);
 
-    m_last_block_processed_height = block.height;
-    m_last_block_processed = block.hash;
+    // Update the best block in memory first. This will set the best block's height, which is
+    // needed by MarkConflicted.
+    SetLastBlockProcessedInMem(block.height, block.hash);
 
     // No need to scan block if it was created before the wallet birthday.
     // Uses chain max time and twice the grace period to adjust time for block time variability.
@@ -1620,11 +1628,17 @@ void CWallet::blockConnected(const interfaces::BlockInfo& block)
 
     // Scan block
     WalletBatch batch(GetDatabase());
+    bool wallet_updated = false;
     for (size_t index = 0; index < block.data->vtx.size(); index++) {
-        SyncTransaction(block.data->vtx[index], TxStateConfirmed{block.hash, block.height, static_cast<int>(index)}, batch);
+        wallet_updated |= SyncTransaction(block.data->vtx[index], TxStateConfirmed{block.hash, block.height, static_cast<int>(index)}, batch);
         transactionRemovedFromMempool(block.data->vtx[index], MemPoolRemovalReason::BLOCK);
     }
 
+    // Update on disk if this block resulted in us updating a tx, or periodically every 144 blocks (~1 day)
+    if (wallet_updated || block.height % 144 == 0) {
+        WriteBestBlock();
+    }
+
     // reset cache to make sure no longer immature coins are included
     fAnonymizableTallyCached = false;
     fAnonymizableTallyCachedNonDenom = false;
@@ -1639,9 +1653,6 @@ void CWallet::blockDisconnected(const interfaces::BlockInfo& block)
     // be unconfirmed, whether or not the transaction is added back to the mempool.
     // User may have to call abandontransaction again. It may be addressed in the
     // future with a stickier abandoned state or even removing abandontransaction call.
-    m_last_block_processed_height = block.height - 1;
-    m_last_block_processed = *Assert(block.prev_hash);
-
     int disconnect_height = block.height;
 
     WalletBatch batch(GetDatabase());
@@ -1677,6 +1688,9 @@ void CWallet::blockDisconnected(const interfaces::BlockInfo& block)
     // reset cache to make sure no longer mature coins are excluded
     fAnonymizableTallyCached = false;
     fAnonymizableTallyCachedNonDenom = false;
+
+    // Update the best block
+    SetLastBlockProcessed(block.height - 1, *Assert(block.prev_hash));
 }
 
 void CWallet::updatedBlockTip()
@@ -2636,7 +2650,7 @@ DBErrors CWallet::LoadWallet()
     if (HaveChain()) {
         const std::optional<int> tip_height = chain().getHeight();
         if (tip_height) {
-            SetLastBlockProcessed(*tip_height, chain().getBlockHash(*tip_height));
+            SetLastBlockProcessedInMem(*tip_height, chain().getBlockHash(*tip_height));
             for (auto& pair : mapWallet) {
                 for(unsigned int i = 0; i < pair.second.tx->vout.size(); ++i) {
                     COutPoint outpoint(pair.first, i);
@@ -3374,6 +3388,8 @@ std::shared_ptr<CWallet> CWallet::Create(WalletContext& context, const std::stri
                      !walletInstance->IsWalletFlagSet(WALLET_FLAG_BLANK_WALLET);
     if (fFirstRun)
     {
+        LOCK(walletInstance->cs_wallet);
+
         walletInstance->SetMinVersion(FEATURE_LATEST);
 
         walletInstance->InitWalletFlags(wallet_creation_flags);
@@ -3401,7 +3417,6 @@ std::shared_ptr<CWallet> CWallet::Create(WalletContext& context, const std::stri
                     }
                     // add default account
                     newHdChain.AddAccount();
-                    LOCK(walletInstance->cs_wallet);
                     if (auto spk_man = walletInstance->GetLegacyScriptPubKeyMan()) {
                         if (!spk_man->AddHDChainSingle(newHdChain)) {
                             error = strprintf(_("%s failed"), "AddHDChainSingle");
@@ -3420,7 +3435,6 @@ std::shared_ptr<CWallet> CWallet::Create(WalletContext& context, const std::stri
 
                     mnemonic = args.GetArg("-mnemonic", "");
                     mnemonic_passphrase = args.GetArg("-mnemonicpassphrase", "");
-                    LOCK(walletInstance->cs_wallet);
                     if (auto spk_man = walletInstance->GetLegacyScriptPubKeyMan()) {
                         spk_man->GenerateNewHDChain(mnemonic, mnemonic_passphrase);
                     }
@@ -3432,7 +3446,6 @@ std::shared_ptr<CWallet> CWallet::Create(WalletContext& context, const std::stri
                 args.ForceRemoveArg("mnemonicpassphrase");
             } // Otherwise, do not create a new HD chain
 
-            LOCK(walletInstance->cs_wallet);
             if (walletInstance->IsWalletFlagSet(WALLET_FLAG_DESCRIPTORS)) {
                 SecureString mnemonic, mnemonic_passphrase;
                 mnemonic.reserve(256);
@@ -3455,7 +3468,10 @@ std::shared_ptr<CWallet> CWallet::Create(WalletContext& context, const std::stri
         }
 
         if (chain) {
-            walletInstance->chainStateFlushed(chain->getTipLocator());
+            std::optional<int> tip_height = chain->getHeight();
+            if (tip_height) {
+                walletInstance->SetLastBlockProcessed(*tip_height, chain->getBlockHash(*tip_height));
+            }
         }
 
         // Try to create wallet backup right after new wallet was created
@@ -3668,16 +3684,11 @@ bool CWallet::AttachChain(const std::shared_ptr<CWallet>& walletInstance, interf
     }
 
     // Register wallet with validationinterface. It's done before rescan to avoid
-    // missing block connections between end of rescan and validation subscribing.
-    // Because of wallet lock being hold, block connection notifications are going to
-    // be pending on the validation-side until lock release. It's likely to have
-    // block processing duplicata (if rescan block range overlaps with notification one)
-    // but we guarantee at least than wallet state is correct after notifications delivery.
-    // However, chainStateFlushed notifications are ignored until the rescan is finished
-    // so that in case of a shutdown event, the rescan will be repeated at the next start.
-    // This is temporary until rescan and notifications delivery are unified under same
-    // interface.
-    walletInstance->m_attaching_chain = true; //ignores chainStateFlushed notifications
+    // missing block connections during the rescan.
+    // Because of the wallet lock being held, block connection notifications are going to
+    // be pending on the validation-side until lock release. Blocks that are connected while the
+    // rescan is ongoing will not be processed in the rescan but with the block connected notifications,
+    // so the wallet will only be completeley synced after the notifications delivery.
     walletInstance->m_chain_notifications_handler = walletInstance->chain().handleNotifications(walletInstance);
 
     // If rescan_required = true, rescan_height remains equal to 0
@@ -3695,11 +3706,9 @@ bool CWallet::AttachChain(const std::shared_ptr<CWallet>& walletInstance, interf
 
     const std::optional<int> tip_height = chain.getHeight();
     if (tip_height) {
-        walletInstance->m_last_block_processed = chain.getBlockHash(*tip_height);
-        walletInstance->m_last_block_processed_height = *tip_height;
+        walletInstance->SetLastBlockProcessedInMem(*tip_height, chain.getBlockHash(*tip_height));
     } else {
-        walletInstance->m_last_block_processed.SetNull();
-        walletInstance->m_last_block_processed_height = -1;
+        walletInstance->SetLastBlockProcessedInMem(-1, uint256());
     }
 
     if (tip_height && *tip_height != rescan_height)
@@ -3754,16 +3763,22 @@ bool CWallet::AttachChain(const std::shared_ptr<CWallet>& walletInstance, interf
         walletInstance->WalletLogPrintf("Rescanning last %i blocks (from block %i)...\n", *tip_height - rescan_height, rescan_height);
         {
             WalletRescanReserver reserver(*walletInstance);
-            if (!reserver.reserve() || (ScanResult::SUCCESS != walletInstance->ScanForWalletTransactions(chain.getBlockHash(rescan_height), rescan_height, /*max_height=*/{}, reserver, /*fUpdate=*/true, /*save_progress=*/true).status)) {
+            if (!reserver.reserve()) {
+                error = _("Failed to acquire rescan reserver during wallet initialization");
+                return false;
+            }
+            ScanResult scan_res = walletInstance->ScanForWalletTransactions(chain.getBlockHash(rescan_height), rescan_height, /*max_height=*/{}, reserver, /*fUpdate=*/true, /*save_progress=*/true);
+            if (ScanResult::SUCCESS != scan_res.status) {
                 error = _("Failed to rescan the wallet during initialization");
                 return false;
             }
+            // Set and update the best block record
+            // Set last block scanned as the last block processed as it may be different in case of a reorg.
+            // Also save the best block locator because rescanning only updates it intermittently.
+            walletInstance->SetLastBlockProcessed(*scan_res.last_scanned_height, scan_res.last_scanned_block);
         }
-        walletInstance->m_attaching_chain = false;
-        walletInstance->chainStateFlushed(chain.getTipLocator());
         walletInstance->GetDatabase().IncrementUpdateCounter();
     }
-    walletInstance->m_attaching_chain = false;
 
     return true;
 }
@@ -3822,6 +3837,8 @@ void CWallet::InitAutoBackup()
 
 bool CWallet::BackupWallet(const std::string& strDest) const
 {
+    // TODO: bitcoin#30678 added a best block write here that bitcoin#30221 then replaced with this call; drop its hunk when backporting it
+    WITH_LOCK(cs_wallet, WriteBestBlock());
     return GetDatabase().Backup(strDest);
 }
 
@@ -5243,6 +5260,7 @@ util::Result<MigrationResult> MigrateLegacyToDescriptor(const std::string& walle
     // If the wallet is still loaded, unload it so that nothing else tries to use it while we're changing it
     bool was_loaded = false;
     if (auto wallet = GetWallet(context, wallet_name)) {
+        // TODO: bitcoin#30678 flushed the best block here; RemoveWallet() writes it since bitcoin#30221, drop that hunk when backporting it
         if (!RemoveWallet(context, wallet, /*load_on_start=*/std::nullopt, warnings)) {
             return util::Error{_("Unable to unload the wallet before migrating")};
         }
@@ -5463,4 +5481,19 @@ util::Result<MigrationResult> MigrateLegacyToDescriptor(const std::string& walle
     }
     return res;
 }
+
+void CWallet::WriteBestBlock() const
+{
+    AssertLockHeld(cs_wallet);
+
+    if (!m_last_block_processed.IsNull()) {
+        CBlockLocator loc;
+        chain().findBlock(m_last_block_processed, FoundBlock().locator(loc));
+
+        if (!loc.IsNull()) {
+            WalletBatch batch(GetDatabase());
+            batch.WriteBestBlock(loc);
+        }
+    }
+}
 } // namespace wallet
diff --git a/src/wallet/wallet.h b/src/wallet/wallet.h
index 45699678003b..98a8711441bf 100644
--- a/src/wallet/wallet.h
+++ b/src/wallet/wallet.h
@@ -329,7 +329,6 @@ class CWallet final : public WalletStorage, public interfaces::Chain::Notificati
 
     std::atomic<bool> fAbortRescan{false}; // reset by WalletRescanReserver::reserve()
     std::atomic<bool> fScanningWallet{false}; // controlled by WalletRescanReserver
-    std::atomic<bool> m_attaching_chain{false};
     std::atomic<bool> m_scanning_with_passphrase{false};
     std::atomic<SteadyClock::time_point> m_scanning_start{SteadyClock::time_point{}};
     std::atomic<double> m_scanning_progress{0};
@@ -420,7 +419,7 @@ class CWallet final : public WalletStorage, public interfaces::Chain::Notificati
 
     void SyncMetaData(std::pair<TxSpends::iterator, TxSpends::iterator>) EXCLUSIVE_LOCKS_REQUIRED(cs_wallet);
 
-    void SyncTransaction(const CTransactionRef& tx, const SyncTxState& state, WalletBatch& batch, bool update_tx = true, bool rescanning_old_block = false) EXCLUSIVE_LOCKS_REQUIRED(cs_wallet);
+    bool SyncTransaction(const CTransactionRef& tx, const SyncTxState& state, WalletBatch& batch, bool update_tx = true, bool rescanning_old_block = false) EXCLUSIVE_LOCKS_REQUIRED(cs_wallet);
 
     /** WalletFlags set on this wallet. */
     std::atomic<uint64_t> m_wallet_flags{0};
@@ -498,6 +497,9 @@ class CWallet final : public WalletStorage, public interfaces::Chain::Notificati
 
     static NodeClock::time_point GetDefaultNextResend();
 
+    // Update last block processed in memory only
+    void SetLastBlockProcessedInMem(int block_height, uint256 block_hash) EXCLUSIVE_LOCKS_REQUIRED(cs_wallet);
+
     PlatformKeyStatus GetPlatformKeySource(const ScriptPubKeyMan*& source) const EXCLUSIVE_LOCKS_REQUIRED(cs_wallet);
     PlatformKeyStatus DerivePlatformKey(const PlatformKeyRequest& request, platformkeys::ExtKey256& out) const
         EXCLUSIVE_LOCKS_REQUIRED(cs_wallet);
@@ -968,7 +970,6 @@ class CWallet final : public WalletStorage, public interfaces::Chain::Notificati
     /** should probably be renamed to IsRelevantToMe */
     bool IsFromMe(const CTransaction& tx) const;
     CAmount GetDebit(const CTransaction& tx, const isminefilter& filter) const;
-    void chainStateFlushed(const CBlockLocator& loc) override;
 
     DBErrors LoadWallet();
     void AutoLockMasternodeCollaterals();
@@ -1206,13 +1207,10 @@ class CWallet final : public WalletStorage, public interfaces::Chain::Notificati
         assert(m_last_block_processed_height >= 0);
         return m_last_block_processed;
     }
-    /** Set last block processed height, currently only use in unit test */
-    void SetLastBlockProcessed(int block_height, uint256 block_hash) EXCLUSIVE_LOCKS_REQUIRED(cs_wallet)
-    {
-        AssertLockHeld(cs_wallet);
-        m_last_block_processed_height = block_height;
-        m_last_block_processed = block_hash;
-    };
+    /** Set last block processed height, and write to database */
+    void SetLastBlockProcessed(int block_height, uint256 block_hash) EXCLUSIVE_LOCKS_REQUIRED(cs_wallet);
+    /** Write the current best block to database */
+    void WriteBestBlock() const EXCLUSIVE_LOCKS_REQUIRED(cs_wallet);
 
     //! Connect the signals from ScriptPubKeyMans to the signals in CWallet
     void ConnectScriptPubKeyManNotifiers();
diff --git a/test/functional/feature_coinstatsindex.py b/test/functional/feature_coinstatsindex.py
index ba5b44635d25..c70eb0c0bf69 100755
--- a/test/functional/feature_coinstatsindex.py
+++ b/test/functional/feature_coinstatsindex.py
@@ -333,6 +333,21 @@ def _test_init_index_after_reorg(self):
         res1 = index_node.gettxoutsetinfo(hash_type='muhash', hash_or_height=None, use_index=True)
         assert_equal(res["muhash"], res1["muhash"])
 
+        self.log.info("Test index with an unclean restart after a reorg")
+        self.restart_node(1, extra_args=self.extra_args[1])
+        committed_height = index_node.getblockcount()
+        self.generate(index_node, 2, sync_fun=self.no_op)
+        self.sync_index_node()
+        block2 = index_node.getbestblockhash()
+        index_node.invalidateblock(block2)
+        self.generatetoaddress(index_node, 1, getnewdestination()[2], sync_fun=self.no_op)
+        self.sync_index_node()
+        index_node.kill_process()
+        self.start_node(1, extra_args=self.extra_args[1])
+        self.sync_index_node()
+        # Because of the unclean shutdown above, indexes reset to the point we last committed them to disk.
+        assert_equal(index_node.getindexinfo()['coinstatsindex']['best_block_height'], committed_height)
+
 
 if __name__ == '__main__':
     CoinStatsIndexTest().main()
diff --git a/test/functional/feature_pruning.py b/test/functional/feature_pruning.py
index b4d9d4edaeff..9571c7bf8802 100755
--- a/test/functional/feature_pruning.py
+++ b/test/functional/feature_pruning.py
@@ -482,6 +482,11 @@ def run_test(self):
         self.connect_nodes(0, 5)
         self.sync_blocks([self.nodes[0], self.nodes[5]], wait=5, timeout=300)
 
+        self.log.info("Test prune with a new index")
+        self.restart_node(0, extra_args=["-txindex=0", "-prune=550", "-blockfilterindex=1"] + DEPLOYMENT_ARGS)
+        node = self.nodes[0]
+        self.wait_until(lambda: node.getindexinfo()["basic block filter index"]["best_block_height"] >= 10, timeout=300)
+
         if self.is_wallet_compiled():
             self.log.info("Test wallet re-scan")
             self.test_wallet_rescan()
diff --git a/test/functional/test_framework/test_node.py b/test/functional/test_framework/test_node.py
index 90cb83ba782c..da038c2740ca 100755
--- a/test/functional/test_framework/test_node.py
+++ b/test/functional/test_framework/test_node.py
@@ -456,8 +456,14 @@ def is_node_stopped(self, *, expected_stderr="", expected_ret_code=0):
         return True
 
     def wait_until_stopped(self, *, timeout=BITCOIND_PROC_WAIT_TIMEOUT, expect_error=False, **kwargs):
-        expected_ret_code = 1 if expect_error else 0  # Whether node shutdown return EXIT_FAILURE or EXIT_SUCCESS
-        wait_until_helper(lambda: self.is_node_stopped(expected_ret_code=expected_ret_code, **kwargs), timeout=timeout, timeout_factor=self.timeout_factor)
+        if "expected_ret_code" not in kwargs:
+            kwargs["expected_ret_code"] = 1 if expect_error else 0  # Whether node shutdown return EXIT_FAILURE or EXIT_SUCCESS
+        wait_until_helper(lambda: self.is_node_stopped(**kwargs), timeout=timeout, timeout_factor=self.timeout_factor)
+
+    def kill_process(self):
+        self.process.kill()
+        self.wait_until_stopped(expected_ret_code=1 if platform.system() == "Windows" else -9)
+        assert self.is_node_stopped()
 
     def replace_in_config(self, replacements):
         """