diff --git a/doc/man/dash-qt.1 b/doc/man/dash-qt.1
index ec4b1a40b8cf..b5d118c05a14 100644
--- a/doc/man/dash-qt.1
+++ b/doc/man/dash-qt.1
@@ -451,7 +451,7 @@ This will also rebuild active optional indexes.
 .IP
 Rebuild chain state from the currently indexed blocks. When in pruning
 mode or if blocks on disk might be corrupted, use full \fB\-reindex\fR
-instead. Deactivate all optional indexes before running this.
+instead.
 .HP
 \fB\-spentindex\fR
 .IP
diff --git a/doc/man/dashd.1 b/doc/man/dashd.1
index 5d4ae91221f1..32fd5dcb4238 100644
--- a/doc/man/dashd.1
+++ b/doc/man/dashd.1
@@ -449,7 +449,7 @@ This will also rebuild active optional indexes.
 .IP
 Rebuild chain state from the currently indexed blocks. When in pruning
 mode or if blocks on disk might be corrupted, use full \fB\-reindex\fR
-instead. Deactivate all optional indexes before running this.
+instead.
 .HP
 \fB\-spentindex\fR
 .IP
diff --git a/src/Makefile.test.include b/src/Makefile.test.include
index 90a0ed75ed64..b43918ed708b 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 \
@@ -138,6 +139,7 @@ BITCOIN_TESTS =\
   test/hash_tests.cpp \
   test/httpserver_tests.cpp \
   test/i2p_tests.cpp \
+  test/index_migration_tests.cpp \
   test/interfaces_tests.cpp \
   test/key_io_tests.cpp \
   test/key_tests.cpp \
diff --git a/src/index/addressindex.cpp b/src/index/addressindex.cpp
index 342de4e359d6..86886a9272f6 100644
--- a/src/index/addressindex.cpp
+++ b/src/index/addressindex.cpp
@@ -398,7 +398,9 @@ bool AddressIndex::CustomRewind(const interfaces::BlockKey& current_tip, const i
         }
     }
 
-    return true;
+    CDBBatch locator_batch(GetDB());
+    WriteRewindLocator(locator_batch, new_tip_index);
+    return GetDB().WriteBatch(locator_batch);
 }
 
 BaseIndex::DB& AddressIndex::GetDB() const { return *m_db; }
diff --git a/src/index/base.cpp b/src/index/base.cpp
index 61b7e7ea768f..24f97f0e0019 100644
--- a/src/index/base.cpp
+++ b/src/index/base.cpp
@@ -22,6 +22,7 @@
 
 using node::PruneLockInfo;
 using node::ReadBlockFromDisk;
+using node::g_indexes_ready_to_sync;
 
 constexpr uint8_t DB_BEST_BLOCK{'B'};
 
@@ -81,14 +82,22 @@ bool BaseIndex::Init()
     if (locator.IsNull()) {
         SetBestBlockIndex(nullptr);
     } else {
-        SetBestBlockIndex(m_chainstate->FindForkInGlobalIndex(locator));
+        // 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))};
+        if (!locator_index) {
+            return InitError(strprintf(Untranslated("%s: best block of the index not found. Please rebuild the index."), GetName()));
+        }
+        SetBestBlockIndex(locator_index);
     }
 
     // Note: this will latch to true immediately if the user starts up with an empty
     // datadir and an index enabled. If this is the case, indexation will happen solely
     // via `BlockConnected` signals until, possibly, the next restart.
     m_synced = m_best_block_index.load() == active_chain.Tip();
-    if (!m_synced) {
+
+    // Skip pruning check if indexes are not ready to sync (because reindex-chainstate has wiped the chain).
+    if (!m_synced && g_indexes_ready_to_sync) {
         bool prune_violation = false;
         if (!m_best_block_index) {
             // index is not built yet
@@ -143,6 +152,12 @@ static const CBlockIndex* NextSyncBlock(const CBlockIndex* pindex_prev, CChain&
 
 void BaseIndex::ThreadSync()
 {
+    // Wait for a possible reindex-chainstate to finish until continuing
+    // with the index sync
+    while (!g_indexes_ready_to_sync) {
+        if (!m_interrupt.sleep_for(std::chrono::milliseconds(500))) return;
+    }
+
     const CBlockIndex* pindex = m_best_block_index.load();
     if (!m_synced) {
         auto& consensus_params = Params().GetConsensus();
@@ -215,12 +230,23 @@ 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) {
+            LogPrint(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);
+            return;
+        }
         CDBBatch batch(GetDB());
         ok = CustomCommit(batch);
         if (ok) {
@@ -230,9 +256,19 @@ bool BaseIndex::Commit()
     }
     if (!ok) {
         LogError("%s: Failed to commit latest %s state\n", __func__, GetName());
-        return false;
     }
-    return true;
+}
+
+void BaseIndex::WriteRewindLocator(CDBBatch& batch, const CBlockIndex* new_tip) const
+{
+    CBlockLocator locator;
+    if (!GetDB().ReadBestBlock(locator) || locator.IsNull()) return;
+    const CBlockIndex* committed = WITH_LOCK(::cs_main, return m_chainstate->m_blockman.LookupBlockIndex(locator.vHave.front()));
+    // 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, or on another branch, needs no change.
+    if (committed && committed->nHeight > new_tip->nHeight && committed->GetAncestor(new_tip->nHeight) == new_tip) {
+        GetDB().WriteBestBlock(batch, GetLocator(*m_chain, new_tip->GetBlockHash()));
+    }
 }
 
 bool BaseIndex::Rewind(const CBlockIndex* current_tip, const CBlockIndex* new_tip)
@@ -244,18 +280,13 @@ bool BaseIndex::Rewind(const CBlockIndex* current_tip, const CBlockIndex* new_ti
         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;
 }
 
diff --git a/src/index/base.h b/src/index/base.h
index db67924d9e75..92bb7df9914c 100644
--- a/src/index/base.h
+++ b/src/index/base.h
@@ -82,14 +82,10 @@ 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.
+    void Commit();
 
     /// Loop over disconnected blocks and call CustomRewind.
     bool Rewind(const CBlockIndex* current_tip, const CBlockIndex* new_tip);
@@ -121,6 +117,11 @@ 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;
+
     virtual DB& GetDB() const = 0;
 
     /// Get the name of the index for display in logs.
diff --git a/src/index/spentindex.cpp b/src/index/spentindex.cpp
index 64c373a151ff..afeb4191f655 100644
--- a/src/index/spentindex.cpp
+++ b/src/index/spentindex.cpp
@@ -158,7 +158,9 @@ bool SpentIndex::CustomRewind(const interfaces::BlockKey& current_tip, const int
         }
     }
 
-    return true;
+    CDBBatch locator_batch(GetDB());
+    WriteRewindLocator(locator_batch, new_tip_index);
+    return GetDB().WriteBatch(locator_batch);
 }
 
 BaseIndex::DB& SpentIndex::GetDB() const { return *m_db; }
diff --git a/src/index/timestampindex.cpp b/src/index/timestampindex.cpp
index 6f1d9af18952..69573472b5ae 100644
--- a/src/index/timestampindex.cpp
+++ b/src/index/timestampindex.cpp
@@ -85,7 +85,9 @@ bool TimestampIndex::CustomRewind(const interfaces::BlockKey& current_tip, const
         }
     }
 
-    return true;
+    CDBBatch locator_batch(GetDB());
+    WriteRewindLocator(locator_batch, new_tip_index);
+    return GetDB().WriteBatch(locator_batch);
 }
 
 BaseIndex::DB& TimestampIndex::GetDB() const { return *m_db; }
diff --git a/src/init.cpp b/src/init.cpp
index 27f73133230f..cb6620cbcf7c 100644
--- a/src/init.cpp
+++ b/src/init.cpp
@@ -169,6 +169,7 @@ using node::CalculateCacheSizes;
 using node::DEFAULT_PERSIST_MEMPOOL;
 using node::DEFAULT_PRINTPRIORITY;
 using node::DEFAULT_STOPAFTERBLOCKIMPORT;
+using node::g_indexes_ready_to_sync;
 using node::LoadChainstate;
 using node::MempoolPath;
 using node::ShouldPersistMempool;
@@ -639,7 +640,7 @@ void SetupServerArgs(ArgsManager& argsman)
 
     argsman.AddArg("-addressindex", strprintf("Maintain a full address index, used to query for the balance, txids and unspent outputs for addresses (default: %u)", DEFAULT_ADDRESSINDEX), ArgsManager::ALLOW_ANY, OptionsCategory::INDEXING);
     argsman.AddArg("-reindex", "Rebuild chain state and block index from the blk*.dat files on disk. This will also rebuild active optional indexes.", ArgsManager::ALLOW_ANY, OptionsCategory::INDEXING);
-    argsman.AddArg("-reindex-chainstate", "Rebuild chain state from the currently indexed blocks. When in pruning mode or if blocks on disk might be corrupted, use full -reindex instead. Deactivate all optional indexes before running this.", ArgsManager::ALLOW_ANY, OptionsCategory::INDEXING);
+    argsman.AddArg("-reindex-chainstate", "Rebuild chain state from the currently indexed blocks. When in pruning mode or if blocks on disk might be corrupted, use full -reindex instead.", ArgsManager::ALLOW_ANY, OptionsCategory::INDEXING);
     argsman.AddArg("-spentindex", strprintf("Maintain a full spent index, used to query the spending txid and input index for an outpoint (default: %u)", DEFAULT_SPENTINDEX), ArgsManager::ALLOW_ANY, OptionsCategory::INDEXING);
     argsman.AddArg("-timestampindex", strprintf("Maintain a timestamp index for block hashes, used to query blocks hashes by a range of timestamps (default: %u)", DEFAULT_TIMESTAMPINDEX), ArgsManager::ALLOW_ANY, OptionsCategory::INDEXING);
     argsman.AddArg("-txindex", strprintf("Maintain a full transaction index, used by the getrawtransaction rpc call (default: %u)", DEFAULT_TXINDEX), ArgsManager::ALLOW_ANY, OptionsCategory::INDEXING);
@@ -1372,19 +1373,6 @@ bool AppInitParameterInteraction(const ArgsManager& args)
     if (args.GetBoolArg("-peerbloomfilters", DEFAULT_PEERBLOOMFILTERS))
         nLocalServices = ServiceFlags(nLocalServices | NODE_BLOOM);
 
-    if (args.GetBoolArg("-reindex-chainstate", false)) {
-        // indexes that must be deactivated to prevent index corruption, see #24630
-        if (args.GetBoolArg("-coinstatsindex", DEFAULT_COINSTATSINDEX)) {
-            return InitError(_("-reindex-chainstate option is not compatible with -coinstatsindex. Please temporarily disable coinstatsindex while using -reindex-chainstate, or replace -reindex-chainstate with -reindex to fully rebuild all indexes."));
-        }
-        if (g_enabled_filter_types.count(BlockFilterType::BASIC_FILTER)) {
-            return InitError(_("-reindex-chainstate option is not compatible with -blockfilterindex. Please temporarily disable blockfilterindex while using -reindex-chainstate, or replace -reindex-chainstate with -reindex to fully rebuild all indexes."));
-        }
-        if (args.GetBoolArg("-txindex", DEFAULT_TXINDEX)) {
-            return InitError(_("-reindex-chainstate option is not compatible with -txindex. Please temporarily disable txindex while using -reindex-chainstate, or replace -reindex-chainstate with -reindex to fully rebuild all indexes."));
-        }
-    }
-
     try {
         const bool fQuorumVvecRequestsEnabled{llmq::GetEnabledQuorumVvecSyncEntries(args).size() > 0};
         if (!args.GetBoolArg("-llmq-data-recovery", llmq::DEFAULT_ENABLE_QUORUM_DATA_RECOVERY) && fQuorumVvecRequestsEnabled) {
@@ -2283,6 +2271,9 @@ bool AppInitMain(NodeContext& node, interfaces::BlockAndHeaderTipInfo* tip_info)
     node.peerman->AddExtraHandler(std::make_unique<SyncManager>(node.peerman.get(), *node.govman, *node.mn_sync, *node.connman, *node.netfulfilledman));
 
     // ********************************************************* Step 8: start indexers
+
+    // If reindex-chainstate was specified, delay syncing indexes until ThreadImport has reindexed the chain
+    if (!fReindexChainState) g_indexes_ready_to_sync = true;
     if (args.GetBoolArg("-txindex", DEFAULT_TXINDEX)) {
         g_txindex = std::make_unique<TxIndex>(interfaces::MakeChain(node), cache_sizes.tx_index, false, fReindex);
         if (!g_txindex->Start()) {
diff --git a/src/node/blockstorage.cpp b/src/node/blockstorage.cpp
index ec84092af90c..339a3133e227 100644
--- a/src/node/blockstorage.cpp
+++ b/src/node/blockstorage.cpp
@@ -29,6 +29,7 @@ std::atomic_bool fImporting(false);
 std::atomic_bool fReindex(false);
 bool fPruneMode = false;
 uint64_t nPruneTarget = 0;
+std::atomic_bool g_indexes_ready_to_sync{false};
 
 bool CBlockIndexWorkComparator::operator()(const CBlockIndex* pa, const CBlockIndex* pb) const
 {
@@ -961,5 +962,6 @@ void ThreadImport(ChainstateManager& chainman, std::vector<fs::path> vImportFile
         }
     } // End scope of CImportingNow
     chainman.ActiveChainstate().LoadMempool(mempool_path);
+    g_indexes_ready_to_sync = true;
 }
 } // namespace node
diff --git a/src/node/blockstorage.h b/src/node/blockstorage.h
index ec7ba9c76e81..4318ae57478f 100644
--- a/src/node/blockstorage.h
+++ b/src/node/blockstorage.h
@@ -50,6 +50,7 @@ extern std::atomic_bool fImporting;
 extern std::atomic_bool fReindex;
 extern bool fPruneMode;
 extern uint64_t nPruneTarget;
+extern std::atomic_bool g_indexes_ready_to_sync;
 
 // Because validation code takes pointers to the map's CBlockIndex objects, if
 // we ever switch to another associative container, we need to either use a
diff --git a/src/test/baseindex_tests.cpp b/src/test/baseindex_tests.cpp
new file mode 100644
index 000000000000..710011a5857b
--- /dev/null
+++ b/src/test/baseindex_tests.cpp
@@ -0,0 +1,238 @@
+// 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 <validation.h>
+#include <validationinterface.h>
+
+#include <boost/test/unit_test.hpp>
+
+namespace {
+//! A minimal index that, like Dash's address, spent and timestamp indexes, keeps one entry per block and erases the
+//! entries of rewound blocks in CustomRewind(). The rewind hooks are exposed 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;
+
+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 { BaseIndex::Stop(); }
+
+    bool Indexed(const CBlockIndex* block) const { return m_db->Exists(std::make_pair(uint8_t{'e'}, block->GetBlockHash())); }
+    bool RewindTo(const CBlockIndex* current_tip, const CBlockIndex* new_tip)
+    {
+        return CustomRewind({current_tip->GetBlockHash(), current_tip->nHeight}, {new_tip->GetBlockHash(), new_tip->nHeight});
+    }
+    void CommitLocator(const CBlockIndex* tip)
+    {
+        CDBBatch batch(*m_db);
+        m_db->WriteBestBlock(batch, GetLocator(tip));
+        BOOST_REQUIRE(m_db->WriteBatch(batch));
+    }
+    void RewindLocatorTo(const CBlockIndex* new_tip)
+    {
+        CDBBatch batch(*m_db);
+        WriteRewindLocator(batch, new_tip);
+        BOOST_REQUIRE(m_db->WriteBatch(batch));
+    }
+    uint256 CommittedTip() const
+    {
+        CBlockLocator locator;
+        BOOST_REQUIRE(m_db->ReadBestBlock(locator) && !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* new_tip_index{WITH_LOCK(::cs_main, return m_chainstate->m_blockman.LookupBlockIndex(new_tip.hash))};
+        for (const CBlockIndex* pindex{WITH_LOCK(::cs_main, return m_chainstate->m_blockman.LookupBlockIndex(current_tip.hash))};
+             pindex != new_tip_index; pindex = pindex->pprev) {
+            if (!m_db->Erase(std::make_pair(uint8_t{'e'}, pindex->GetBlockHash()))) return false;
+        }
+        CDBBatch batch(*m_db);
+        WriteRewindLocator(batch, new_tip_index);
+        return m_db->WriteBatch(batch);
+    }
+    BaseIndex::DB& GetDB() const override { return *m_db; }
+    bool AllowPrune() const override { return true; }
+};
+
+const CBlockIndex* AtHeight(ChainstateManager& chainman, int height)
+{
+    return WITH_LOCK(::cs_main, return chainman.ActiveChain()[height]);
+}
+
+//! Makes the chainstate's last flushed block `height`, below the current tip, by flushing while the blocks above
+//! are disconnected and then connecting 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. Hold back the
+        // sync thread so the loaded best block is not advanced before it 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 the last
+    // flushed block is behind it, 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 the 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
+    // (the 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);
+}
+
+// An index that erases entries when it rewinds must not leave its committed locator above them, even while the
+// rewound tip is ahead of the last flush and Commit() can't write it.
+BOOST_FIXTURE_TEST_CASE(rewind_locator_follows_erased_entries, TestChain100Setup)
+{
+    ChainstateManager& chainman{*Assert(m_node.chainman)};
+    Chainstate& chainstate{chainman.ActiveChainstate()};
+
+    // A competing block at height 98 that stays off the active chain
+    CBlockIndex* old_98{WITH_LOCK(::cs_main, return chainman.ActiveChain()[98])};
+    BlockValidationState state;
+    BOOST_REQUIRE(chainstate.InvalidateBlock(state, old_98));
+    const uint256 competing_98{CreateAndProcessBlock({}, CScript() << OP_TRUE).GetHash()};
+    WITH_LOCK(::cs_main, chainstate.ResetBlockFailureFlags(old_98));
+    BOOST_REQUIRE(chainstate.ActivateBestChain(state));
+    const CBlockIndex* competing{WITH_LOCK(::cs_main, return chainman.m_blockman.LookupBlockIndex(competing_98))};
+    BOOST_REQUIRE_EQUAL(AtHeight(chainman, 100)->nHeight, 100);
+    chainstate.ForceFlushStateToDisk();
+    BOOST_REQUIRE_EQUAL(WITH_LOCK(::cs_main, return chainstate.GetLastFlushedBlock()->nHeight), 100);
+
+    node::g_indexes_ready_to_sync = false;
+    ErasingIndex index{interfaces::MakeChain(m_node)};
+    BOOST_REQUIRE(index.Start());
+
+    // Committed tip above the target on the same branch: the locator moves down to the target
+    index.CommitLocator(AtHeight(chainman, 100));
+    index.RewindLocatorTo(AtHeight(chainman, 97));
+    BOOST_CHECK(index.CommittedTip() == AtHeight(chainman, 97)->GetBlockHash());
+
+    // Committed tip equal to the target: unchanged
+    index.CommitLocator(AtHeight(chainman, 100));
+    index.RewindLocatorTo(AtHeight(chainman, 100));
+    BOOST_CHECK(index.CommittedTip() == AtHeight(chainman, 100)->GetBlockHash());
+
+    // Target on another branch: unchanged, never lowered to a common ancestor below entries that stay
+    index.RewindLocatorTo(competing);
+    BOOST_CHECK(index.CommittedTip() == AtHeight(chainman, 100)->GetBlockHash());
+
+    // Committed tip below the target: unchanged, a restart re-appends from it
+    index.CommitLocator(AtHeight(chainman, 95));
+    index.RewindLocatorTo(AtHeight(chainman, 97));
+    BOOST_CHECK(index.CommittedTip() == AtHeight(chainman, 95)->GetBlockHash());
+
+    index.Interrupt();
+    index.Stop();
+    node::g_indexes_ready_to_sync = true;
+}
+
+// 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.
+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 ahead of the last flush (95), so Commit() could not 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));
+        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();
+}
+
+BOOST_AUTO_TEST_SUITE_END()
diff --git a/src/test/index_migration_tests.cpp b/src/test/index_migration_tests.cpp
new file mode 100644
index 000000000000..3eae5e0ee4bb
--- /dev/null
+++ b/src/test/index_migration_tests.cpp
@@ -0,0 +1,69 @@
+// Copyright (c) 2026 The Dash Core developers
+// Distributed under the MIT software license, see the accompanying
+// file COPYING or http://www.opensource.org/licenses/mit-license.php.
+
+#include <coins.h>
+#include <index/timestampindex.h>
+#include <interfaces/chain.h>
+#include <node/blockstorage.h>
+#include <test/util/setup_common.h>
+#include <txdb.h>
+#include <util/system.h>
+#include <validation.h>
+
+#include <boost/test/unit_test.hpp>
+
+namespace {
+struct IndexMigrationSetup : public TestChainSetup {
+    IndexMigrationSetup() :
+        TestChainSetup{100, CBaseChainParams::REGTEST, {"-timestampindex=1"}}
+    {
+    }
+
+    //! Give MigrateOldIndexData() the on-disk chainstate best block it reads on a real node.
+    void WriteChainstateBestBlock()
+    {
+        const uint256 tip{WITH_LOCK(cs_main, return m_node.chainman->ActiveChain().Tip()->GetBlockHash())};
+        CCoinsViewDB coins_db{gArgs.GetDataDirNet() / "chainstate", /*nCacheSize=*/1 << 20, /*fMemory=*/false,
+                              /*fWipe=*/false};
+        CCoinsMapMemoryResource resource;
+        CCoinsMap no_coins{0, CCoinsMap::hasher{}, CCoinsMap::key_equal{}, &resource};
+        BOOST_REQUIRE(coins_db.BatchWrite(no_coins, tip));
+    }
+
+    //! Height the timestamp index resumes from, read before its sync thread can advance it.
+    int LoadedTimestampIndexHeight()
+    {
+        node::g_indexes_ready_to_sync = false;
+        TimestampIndex index{interfaces::MakeChain(m_node), /*n_cache_size=*/1 << 20};
+        BOOST_REQUIRE(index.Start());
+        const int height{index.GetSummary().best_block_height};
+        index.Interrupt();
+        index.Stop();
+        node::g_indexes_ready_to_sync = true;
+        return height;
+    }
+};
+} // namespace
+
+BOOST_AUTO_TEST_SUITE(index_migration_tests)
+
+// A datadir upgraded from v23 keeps its legacy "timestampindex" flag. If the index's own
+// database is then missing (deleted to rebuild it), there is nothing left to migrate, and
+// the empty database must not be stamped with the chain tip as if it were synced.
+BOOST_FIXTURE_TEST_CASE(empty_index_is_not_adopted_as_migrated, IndexMigrationSetup)
+{
+    WriteChainstateBestBlock();
+    CBlockTreeDB& block_tree_db{*WITH_LOCK(cs_main, return m_node.chainman->m_blockman.m_block_tree_db.get())};
+    BOOST_REQUIRE(block_tree_db.WriteFlag("timestampindex", true));
+
+    BOOST_REQUIRE(WITH_LOCK(cs_main, return block_tree_db.MigrateOldIndexData()));
+
+    BOOST_CHECK_EQUAL(LoadedTimestampIndexHeight(), 0);
+    // The legacy entries are gone, so older versions must not trust their synchronous index either.
+    bool legacy_current{true};
+    BOOST_REQUIRE(block_tree_db.ReadFlag("timestampindex", legacy_current));
+    BOOST_CHECK(!legacy_current);
+}
+
+BOOST_AUTO_TEST_SUITE_END()
diff --git a/src/test/util/setup_common.cpp b/src/test/util/setup_common.cpp
index fcf071dcd598..50170ce9872a 100644
--- a/src/test/util/setup_common.cpp
+++ b/src/test/util/setup_common.cpp
@@ -223,6 +223,7 @@ BasicTestingSetup::BasicTestingSetup(const std::string& chainName, const std::ve
     }
 
     bls::bls_legacy_scheme.store(true);
+    node::g_indexes_ready_to_sync = true;
 }
 
 BasicTestingSetup::~BasicTestingSetup()
diff --git a/src/test/validation_flush_tests.cpp b/src/test/validation_flush_tests.cpp
index 3e377d851c9b..0159069b2195 100644
--- a/src/test/validation_flush_tests.cpp
+++ b/src/test/validation_flush_tests.cpp
@@ -8,6 +8,7 @@
 #include <test/util/random.h>
 #include <test/util/setup_common.h>
 #include <validation.h>
+#include <validationinterface.h>
 
 #include <boost/test/unit_test.hpp>
 
@@ -155,4 +156,52 @@ BOOST_AUTO_TEST_CASE(getcoinscachesizestate)
         CoinsCacheSizeState::OK);
 }
 
+namespace {
+struct FlushOrderSubscriber final : public CValidationInterface {
+    std::set<uint256> m_connected;
+    bool m_new_block_connected{false};
+    int m_flushes_before_connect{0};
+    bool m_flushed_unconnected{false};
+
+    void BlockConnected(const std::shared_ptr<const CBlock>&, const CBlockIndex* pindex) override
+    {
+        if (m_connected.insert(pindex->GetBlockHash()).second) m_new_block_connected = true;
+    }
+    void ChainStateFlushed(const CBlockLocator& locator) override
+    {
+        if (!m_new_block_connected) ++m_flushes_before_connect;
+        if (!m_connected.count(locator.vHave.front())) m_flushed_unconnected = true;
+    }
+};
+
+struct CriticalCacheSetup : public TestChainSetup {
+    CriticalCacheSetup() :
+        TestChainSetup{100, CBaseChainParams::REGTEST, {"-maxmempool=0"}}
+    {
+    }
+};
+} // namespace
+
+//! A flush inside ConnectTip() must not announce the block being connected before its BlockConnected
+//! notification, since the wallet stores the announced locator as the point it has scanned up to.
+BOOST_FIXTURE_TEST_CASE(chainstate_flushed_after_block_connected, CriticalCacheSetup)
+{
+    Chainstate& chainstate{m_node.chainman->ActiveChainstate()};
+    auto sub{std::make_shared<FlushOrderSubscriber>()};
+    WITH_LOCK(::cs_main, for (const CBlockIndex* pindex{chainstate.m_chain.Tip()}; pindex; pindex = pindex->pprev) {
+        sub->m_connected.insert(pindex->GetBlockHash());
+    });
+    RegisterSharedValidationInterface(sub);
+    // With no coins cache budget and no mempool allowance, every ConnectTip() flushes.
+    WITH_LOCK(::cs_main, chainstate.m_coinstip_cache_size_bytes = 0);
+
+    CreateAndProcessBlock({}, CScript() << OP_TRUE);
+    SyncWithValidationInterfaceQueue();
+    UnregisterSharedValidationInterface(sub);
+
+    // ConnectTip() flushed before the new block's BlockConnected was delivered.
+    BOOST_CHECK_GT(sub->m_flushes_before_connect, 0);
+    BOOST_CHECK(!sub->m_flushed_unconnected);
+}
+
 BOOST_AUTO_TEST_SUITE_END()
diff --git a/src/txdb.cpp b/src/txdb.cpp
index 4ec4ce9f3702..8916f14f79f1 100644
--- a/src/txdb.cpp
+++ b/src/txdb.cpp
@@ -479,14 +479,17 @@ static bool FinalizeMigration(CDBWrapper& target_db, const uint256& best_block_h
     return true;
 }
 
-// Returns true if the target index database has no best-block locator yet —
-// i.e. the new async index has never been finalized on this datadir. Used to
-// guard FinalizeMigration so we don't regress an already-advanced locator
-// (e.g. left by ThreadSync after a previous successful migration).
+// Returns true if the target index database holds migrated entries but no best-block
+// locator yet, i.e. a migration copied data that was never finalized. Used to guard
+// FinalizeMigration so we don't regress an already-advanced locator (e.g. left by
+// ThreadSync after a previous successful migration), and so we never stamp the chain
+// tip onto an empty target (e.g. index directories deleted after an earlier migration
+// already moved the legacy entries), which would report an empty index as synced.
 static bool TargetNeedsLocator(CDBWrapper& target_db)
 {
     CBlockLocator existing;
-    return !target_db.Read(DB_BEST_BLOCK, existing) || existing.IsNull();
+    if (target_db.Read(DB_BEST_BLOCK, existing) && !existing.IsNull()) return false;
+    return !target_db.IsEmpty();
 }
 
 bool CBlockTreeDB::MigrateOldIndexData()
@@ -523,7 +526,11 @@ bool CBlockTreeDB::MigrateOldIndexData()
     // the legacy entries don't cover the suffix of the chain that ran with the index
     // disabled, and copying them while stamping the chainstate tip as the locator would
     // mark an incomplete index as fully synced. In that case we discard the source entries
-    // instead and let the new async index resync from genesis.
+    // instead and let the new async index resync from genesis. Once an enabled index has been
+    // processed its legacy entries are gone, so its flag is cleared: a later start must never
+    // adopt whatever the new database then holds (for example a partial rebuild after the
+    // index directory was deleted) as migrated data, and older versions see that their
+    // synchronous index needs a reindex.
     bool legacy_flag = false;
     const bool addressindex_was_current   = ReadFlag("addressindex",   legacy_flag) && legacy_flag;
     const bool spentindex_was_current     = ReadFlag("spentindex",     legacy_flag) && legacy_flag;
@@ -579,12 +586,14 @@ bool CBlockTreeDB::MigrateOldIndexData()
             return false;
         }
         // Finalize even when count==0 to recover from a previous run that crashed
-        // after writing target data but before writing the locator.
+        // after writing target data but before writing the locator. An empty target is
+        // left without a locator, so the index rebuilds from genesis.
         if (timestampindex_was_current && TargetNeedsLocator(timestamp_db)) {
             if (!FinalizeMigration(timestamp_db, best_block_hash, "timestamp index")) {
                 return false;
             }
         }
+        WriteFlag("timestampindex", false);
     }
 
     // Migrate spent index (only if enabled)
@@ -603,6 +612,7 @@ bool CBlockTreeDB::MigrateOldIndexData()
                 return false;
             }
         }
+        WriteFlag("spentindex", false);
     }
 
     // Migrate address index (includes both address and unspent indexes) (only if enabled)
@@ -631,6 +641,7 @@ bool CBlockTreeDB::MigrateOldIndexData()
                 return false;
             }
         }
+        WriteFlag("addressindex", false);
     }
 
     if (total_count > 0) {
diff --git a/src/validation.cpp b/src/validation.cpp
index da6025861e4c..4ce3c0fa9c69 100644
--- a/src/validation.cpp
+++ b/src/validation.cpp
@@ -3102,6 +3102,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");
@@ -3120,9 +3121,13 @@ 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());
+        // Dash's wallet still persists this locator as its best block (bitcoin#30221 removed that upstream).
+        // ConnectTip() can flush before the new block is part of m_chain, so announce the last flushed
+        // block that is.
+        if (const CBlockIndex* flushed_in_chain{m_chain.FindFork(m_last_flushed_block)}) {
+            GetMainSignals().ChainStateFlushed(GetLocator(flushed_in_chain));
+        }
     }
     } catch (const std::runtime_error& e) {
         return AbortNode(state, std::string("System error while flushing: ") + e.what());
@@ -5017,6 +5022,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 de5c2fc754e8..24111786b252 100644
--- a/src/validation.h
+++ b/src/validation.h
@@ -766,6 +766,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)
     {
@@ -810,6 +813,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/test/functional/feature_addressindex.py b/test/functional/feature_addressindex.py
index 8986d4a15930..e14c23de942e 100755
--- a/test/functional/feature_addressindex.py
+++ b/test/functional/feature_addressindex.py
@@ -19,7 +19,8 @@
     keyhash_to_p2pkh_script,
     scripthash_to_p2sh_script,
 )
-from test_framework.util import assert_equal
+from test_framework.util import assert_equal, assert_greater_than
+from test_framework.wallet import getnewdestination
 
 class AddressIndexTest(BitcoinTestFramework):
     def add_options(self, parser):
@@ -341,8 +342,31 @@ def run_test(self):
         mempool_deltas = self.nodes[2].getaddressmempool({"addresses": [address1]})
         assert_equal(len(mempool_deltas), 2)
 
+        self.test_reorg_while_disabled()
+
         self.log.info("Passed")
 
+    def wait_index_synced(self, node):
+        self.wait_until(lambda: node.getindexinfo()["addressindex"] == {"synced": True, "best_block_height": node.getblockcount()})
+
+    def test_reorg_while_disabled(self):
+        self.log.info("Test that blocks orphaned while the index was disabled are removed from it")
+        node = self.nodes[3]
+        self.disconnect_nodes(0, 3)
+        orphan_address = getnewdestination()[2]
+        orphan_block = self.generatetoaddress(node, 1, orphan_address, sync_fun=self.no_op)[0]
+        self.wait_index_synced(node)
+        assert_greater_than(node.getaddressbalance(orphan_address)["received"], 0)
+
+        self.restart_node(3, ["-addressindex=0"])
+        node.invalidateblock(orphan_block)
+        self.generatetoaddress(node, 2, getnewdestination()[2], sync_fun=self.no_op)
+
+        self.restart_node(3, ["-addressindex"])
+        self.wait_index_synced(node)
+        assert_equal(node.getaddressbalance(orphan_address)["received"], 0)
+        assert_equal(node.getaddresstxids(orphan_address), [])
+
 
 if __name__ == '__main__':
     AddressIndexTest().main()
diff --git a/test/functional/feature_coinstatsindex.py b/test/functional/feature_coinstatsindex.py
index eac67a631e3b..e9d62a22fce6 100755
--- a/test/functional/feature_coinstatsindex.py
+++ b/test/functional/feature_coinstatsindex.py
@@ -12,6 +12,7 @@
 import struct
 
 from decimal import Decimal
+import platform
 
 from test_framework.blocktools import (
     create_block,
@@ -54,6 +55,7 @@ def run_test(self):
         self._test_use_index_option()
         self._test_reorg_index()
         self._test_index_rejects_hash_serialized()
+        self._test_init_index_after_reorg()
 
     def block_subsidy(self, prev_bits):
         # Subsidy calculations valid till block 4500
@@ -75,6 +77,9 @@ def block_sanity_check(self, block_info, prev_height):
             block_info['new_outputs_ex_coinbase'] + block_info['coinbase'] + block_info['unspendable']
         )
 
+    def sync_index_node(self):
+        self.wait_until(lambda: self.nodes[1].getindexinfo()['coinstatsindex']['synced'] is True)
+
     def _test_coin_stats_index(self):
         node = self.nodes[0]
         index_node = self.nodes[1]
@@ -237,18 +242,16 @@ def _test_coin_stats_index(self):
         self.log.info("Test that the index works with -reindex")
 
         self.restart_node(1, extra_args=["-coinstatsindex", "-reindex"])
+        self.sync_index_node()
         res11 = index_node.gettxoutsetinfo('muhash')
         assert_equal(res11, res10)
 
-        self.log.info("Test that -reindex-chainstate is disallowed with coinstatsindex")
+        self.log.info("Test that the index works with -reindex-chainstate")
 
-        self.stop_node(1)
-        self.nodes[1].assert_start_raises_init_error(
-            expected_msg='Error: -reindex-chainstate option is not compatible with -coinstatsindex. '
-            'Please temporarily disable coinstatsindex while using -reindex-chainstate, or replace -reindex-chainstate with -reindex to fully rebuild all indexes.',
-            extra_args=['-coinstatsindex', '-reindex-chainstate'],
-        )
-        self.restart_node(1, extra_args=["-coinstatsindex"])
+        self.restart_node(1, extra_args=["-coinstatsindex", "-reindex-chainstate"])
+        self.sync_index_node()
+        res12 = index_node.gettxoutsetinfo('muhash')
+        assert_equal(res12, res10)
 
         self.log.info("Test obtaining info for a non-existent block hash")
         assert_raises_rpc_error(-5, "Block not found", index_node.gettxoutsetinfo, hash_type="none", hash_or_height="ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff", use_index=True)
@@ -270,6 +273,7 @@ def _test_reorg_index(self):
         index_node = self.nodes[1]
         reorg_blocks = self.generatetoaddress(index_node, 2, getnewdestination()[2])
         reorg_block = reorg_blocks[1]
+        self.sync_index_node()
         res_invalid = index_node.gettxoutsetinfo('muhash')
         index_node.invalidateblock(reorg_blocks[0])
         assert_equal(index_node.gettxoutsetinfo('muhash')['height'], 110)
@@ -309,6 +313,45 @@ def _test_index_rejects_hash_serialized(self):
         for use_index in {True, False, None}:
             assert_raises_rpc_error(-8, msg, self.nodes[1].gettxoutsetinfo, hash_type='hash_serialized_2', hash_or_height=111, use_index=use_index)
 
+    def _test_init_index_after_reorg(self):
+        self.log.info("Test a reorg while the index is deactivated")
+        index_node = self.nodes[1]
+        block = self.nodes[0].getbestblockhash()
+        self.generate(index_node, 2, sync_fun=self.no_op)
+        self.sync_index_node()
+
+        # Restart without index
+        self.restart_node(1, extra_args=[])
+        self.connect_nodes(0, 1)
+        index_node.invalidateblock(block)
+        self.generatetoaddress(index_node, 5, getnewdestination()[2])
+        res = index_node.gettxoutsetinfo(hash_type='muhash', hash_or_height=None, use_index=False)
+
+        # Restart with index that still has its best block on the old chain
+        self.restart_node(1, extra_args=self.extra_args[1])
+        self.sync_index_node()
+        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()
+        # The index stays "synced" across the reorg, so make sure it has processed the rewind before the kill.
+        index_node.syncwithvalidationinterfacequeue()
+        index_node.process.kill()
+        index_node.process.wait()
+        assert index_node.is_node_stopped(expected_ret_code=1 if platform.system() == "Windows" else -9)
+        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/p2p_blockfilters.py b/test/functional/p2p_blockfilters.py
index 6d3902f62a74..b28bd45e635d 100755
--- a/test/functional/p2p_blockfilters.py
+++ b/test/functional/p2p_blockfilters.py
@@ -293,13 +293,6 @@ def run_test(self):
         msg = "Error: Unknown -blockfilterindex value abc."
         self.nodes[0].assert_start_raises_init_error(expected_msg=msg)
 
-        self.log.info("Test -blockfilterindex with -reindex-chainstate raises an error")
-        self.nodes[0].assert_start_raises_init_error(
-            expected_msg='Error: -reindex-chainstate option is not compatible with -blockfilterindex. '
-            'Please temporarily disable blockfilterindex while using -reindex-chainstate, or replace -reindex-chainstate with -reindex to fully rebuild all indexes.',
-            extra_args=['-blockfilterindex', '-reindex-chainstate'],
-        )
-
         self.test_special_transactions_in_filters()
 
     def create_simple_assetlock(self, base_tx, base_tx_value, amount_locked_1, amount_locked_2=0):
diff --git a/test/functional/wallet_backup.py b/test/functional/wallet_backup.py
index ba7007bee964..f68424dfec68 100755
--- a/test/functional/wallet_backup.py
+++ b/test/functional/wallet_backup.py
@@ -254,6 +254,7 @@ def run_test(self):
             shutil.rmtree(os.path.join(self.nodes[2].datadir, self.chain, 'chainstate'))
             shutil.rmtree(os.path.join(self.nodes[2].datadir, self.chain, 'evodb'))
             shutil.rmtree(os.path.join(self.nodes[2].datadir, self.chain, 'llmq'))
+            shutil.rmtree(os.path.join(self.nodes[2].datadir, self.chain, 'indexes'))
 
             self.start_three(["-nowallet"])
             # Create new wallets for the three nodes.
diff --git a/test/functional/wallet_hd.py b/test/functional/wallet_hd.py
index 87da58189f93..c7103ef65f3f 100755
--- a/test/functional/wallet_hd.py
+++ b/test/functional/wallet_hd.py
@@ -90,6 +90,7 @@ def run_test(self):
         shutil.rmtree(os.path.join(self.nodes[1].datadir, self.chain, "chainstate"))
         shutil.rmtree(os.path.join(self.nodes[1].datadir, self.chain, "evodb"))
         shutil.rmtree(os.path.join(self.nodes[1].datadir, self.chain, "llmq"))
+        shutil.rmtree(os.path.join(self.nodes[1].datadir, self.chain, "indexes"))
         shutil.copyfile(
             os.path.join(self.nodes[1].datadir, "hd.bak"),
             os.path.join(self.nodes[1].datadir, self.chain, "wallets", self.default_wallet_name, self.wallet_data_filename),
@@ -117,6 +118,7 @@ def run_test(self):
         shutil.rmtree(os.path.join(self.nodes[1].datadir, self.chain, "chainstate"))
         shutil.rmtree(os.path.join(self.nodes[1].datadir, self.chain, "evodb"))
         shutil.rmtree(os.path.join(self.nodes[1].datadir, self.chain, "llmq"))
+        shutil.rmtree(os.path.join(self.nodes[1].datadir, self.chain, "indexes"))
         shutil.copyfile(
             os.path.join(self.nodes[1].datadir, "hd.bak"),
             os.path.join(self.nodes[1].datadir, self.chain, "wallets", self.default_wallet_name, self.wallet_data_filename),
diff --git a/test/util/data/non-backported.txt b/test/util/data/non-backported.txt
index 9b4c7e20023d..a616995691fd 100644
--- a/test/util/data/non-backported.txt
+++ b/test/util/data/non-backported.txt
@@ -96,6 +96,7 @@ src/test/unordered_lru_cache_tests.cpp
 src/test/util/llmq_tests.h
 src/test/util/masternode.*
 src/test/governance*.cpp
+src/test/index_migration_tests.cpp
 src/unordered_lru_cache.h
 src/util/edge.*
 src/util/helpers.h