diff --git a/src/test/blockfilter_index_tests.cpp b/src/test/blockfilter_index_tests.cpp
index 0b7192262..ec425f002 100644
--- a/src/test/blockfilter_index_tests.cpp
+++ b/src/test/blockfilter_index_tests.cpp
@@ -1,159 +1,281 @@
 // Copyright (c) 2017-2018 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 <blockfilter.h>
 #include <chainparams.h>
+#include <config.h>
+#include <consensus/validation.h>
 #include <index/blockfilterindex.h>
+#include <miner.h>
+#include <pow.h>
 #include <script/standard.h>
 #include <test/setup_common.h>
 #include <validation.h>
 
 #include <boost/test/unit_test.hpp>
 
 BOOST_AUTO_TEST_SUITE(blockfilter_index_tests)
 
 static bool ComputeFilter(BlockFilterType filter_type,
                           const CBlockIndex *block_index, BlockFilter &filter) {
     CBlock block;
     if (!ReadBlockFromDisk(block, block_index->GetBlockPos(),
                            Params().GetConsensus())) {
         return false;
     }
 
     CBlockUndo block_undo;
     if (block_index->nHeight > 0 &&
         !UndoReadFromDisk(block_undo, block_index)) {
         return false;
     }
 
     filter = BlockFilter(filter_type, block, block_undo);
     return true;
 }
 
 static bool CheckFilterLookups(BlockFilterIndex &filter_index,
                                const CBlockIndex *block_index,
                                uint256 &last_header) {
     BlockFilter expected_filter;
     if (!ComputeFilter(filter_index.GetFilterType(), block_index,
                        expected_filter)) {
         BOOST_ERROR("ComputeFilter failed on block " << block_index->nHeight);
         return false;
     }
 
     BlockFilter filter;
     uint256 filter_header;
     std::vector<BlockFilter> filters;
     std::vector<uint256> filter_hashes;
 
     BOOST_CHECK(filter_index.LookupFilter(block_index, filter));
     BOOST_CHECK(filter_index.LookupFilterHeader(block_index, filter_header));
     BOOST_CHECK(filter_index.LookupFilterRange(block_index->nHeight,
                                                block_index, filters));
     BOOST_CHECK(filter_index.LookupFilterHashRange(block_index->nHeight,
                                                    block_index, filter_hashes));
 
     BOOST_CHECK_EQUAL(filters.size(), 1);
     BOOST_CHECK_EQUAL(filter_hashes.size(), 1);
 
     BOOST_CHECK_EQUAL(filter.GetHash(), expected_filter.GetHash());
     BOOST_CHECK_EQUAL(filter_header,
                       expected_filter.ComputeHeader(last_header));
     BOOST_CHECK_EQUAL(filters[0].GetHash(), expected_filter.GetHash());
     BOOST_CHECK_EQUAL(filter_hashes[0], expected_filter.GetHash());
 
     filters.clear();
     filter_hashes.clear();
     last_header = filter_header;
     return true;
 }
 
+static CBlock CreateBlock(const CBlockIndex *prev,
+                          const std::vector<CMutableTransaction> &txns,
+                          const CScript &scriptPubKey) {
+    const Config &config = GetConfig();
+    std::unique_ptr<CBlockTemplate> pblocktemplate =
+        BlockAssembler(config, g_mempool).CreateNewBlock(scriptPubKey);
+    CBlock &block = pblocktemplate->block;
+    block.hashPrevBlock = prev->GetBlockHash();
+    block.nTime = prev->nTime + 1;
+
+    // Replace mempool-selected txns with just coinbase plus passed-in txns:
+    block.vtx.resize(1);
+    for (const CMutableTransaction &tx : txns) {
+        block.vtx.push_back(MakeTransactionRef(tx));
+    }
+    // IncrementExtraNonce creates a valid coinbase and merkleRoot
+    unsigned int extraNonce = 0;
+    IncrementExtraNonce(&block, prev, config.GetMaxBlockSize(), extraNonce);
+
+    while (!CheckProofOfWork(block.GetHash(), block.nBits,
+                             config.GetChainParams().GetConsensus())) {
+        ++block.nNonce;
+    }
+
+    return block;
+}
+
+static bool BuildChain(const CBlockIndex *pindex,
+                       const CScript &coinbase_script_pub_key, size_t length,
+                       std::vector<std::shared_ptr<CBlock>> &chain) {
+    std::vector<CMutableTransaction> no_txns;
+
+    chain.resize(length);
+    for (auto &block : chain) {
+        block = std::make_shared<CBlock>(
+            CreateBlock(pindex, no_txns, coinbase_script_pub_key));
+        CBlockHeader header = block->GetBlockHeader();
+
+        CValidationState state;
+        if (!ProcessNewBlockHeaders(GetConfig(), {header}, state, &pindex,
+                                    nullptr)) {
+            return false;
+        }
+    }
+
+    return true;
+}
+
 BOOST_FIXTURE_TEST_CASE(blockfilter_index_initial_sync, TestChain100Setup) {
     BlockFilterIndex filter_index(BlockFilterType::BASIC, 1 << 20, true);
 
     uint256 last_header;
 
     // Filter should not be found in the index before it is started.
     {
         LOCK(cs_main);
 
         BlockFilter filter;
         uint256 filter_header;
         std::vector<BlockFilter> filters;
         std::vector<uint256> filter_hashes;
 
         for (const CBlockIndex *block_index = ::ChainActive().Genesis();
              block_index != nullptr;
              block_index = ::ChainActive().Next(block_index)) {
             BOOST_CHECK(!filter_index.LookupFilter(block_index, filter));
             BOOST_CHECK(
                 !filter_index.LookupFilterHeader(block_index, filter_header));
             BOOST_CHECK(!filter_index.LookupFilterRange(block_index->nHeight,
                                                         block_index, filters));
             BOOST_CHECK(!filter_index.LookupFilterHashRange(
                 block_index->nHeight, block_index, filter_hashes));
         }
     }
 
     // BlockUntilSyncedToCurrentChain should return false before index is
     // started.
     BOOST_CHECK(!filter_index.BlockUntilSyncedToCurrentChain());
 
     filter_index.Start();
 
     // Allow filter index to catch up with the block index.
     constexpr int64_t timeout_ms = 10 * 1000;
     int64_t time_start = GetTimeMillis();
     while (!filter_index.BlockUntilSyncedToCurrentChain()) {
         BOOST_REQUIRE(time_start + timeout_ms > GetTimeMillis());
         MilliSleep(100);
     }
 
     // Check that filter index has all blocks that were in the chain before it
     // started.
     {
         LOCK(cs_main);
         const CBlockIndex *block_index;
         for (block_index = ::ChainActive().Genesis(); block_index != nullptr;
              block_index = ::ChainActive().Next(block_index)) {
             CheckFilterLookups(filter_index, block_index, last_header);
         }
     }
 
-    // Check that new blocks get indexed.
-    for (int i = 0; i < 10; i++) {
-        CScript coinbase_script_pub_key =
-            GetScriptForDestination(coinbaseKey.GetPubKey().GetID());
-        std::vector<CMutableTransaction> no_txns;
-        const CBlock &block =
-            CreateAndProcessBlock(no_txns, coinbase_script_pub_key);
+    // Create two forks.
+    const CBlockIndex *tip;
+    {
+        LOCK(cs_main);
+        tip = ::ChainActive().Tip();
+    }
+    CScript coinbase_script_pub_key =
+        GetScriptForDestination(coinbaseKey.GetPubKey().GetID());
+    std::vector<std::shared_ptr<CBlock>> chainA, chainB;
+    BOOST_REQUIRE(BuildChain(tip, coinbase_script_pub_key, 10, chainA));
+    BOOST_REQUIRE(BuildChain(tip, coinbase_script_pub_key, 10, chainB));
+
+    // Check that new blocks on chain A get indexed.
+    uint256 chainA_last_header = last_header;
+    for (size_t i = 0; i < 2; i++) {
+        const auto &block = chainA[i];
+        BOOST_REQUIRE(ProcessNewBlock(GetConfig(), block, true, nullptr));
+
         const CBlockIndex *block_index;
         {
             LOCK(cs_main);
-            block_index = LookupBlockIndex(block.GetHash());
+            block_index = LookupBlockIndex(block->GetHash());
         }
 
         BOOST_CHECK(filter_index.BlockUntilSyncedToCurrentChain());
-        CheckFilterLookups(filter_index, block_index, last_header);
+        CheckFilterLookups(filter_index, block_index, chainA_last_header);
+    }
+
+    // Reorg to chain B.
+    uint256 chainB_last_header = last_header;
+    for (size_t i = 0; i < 3; i++) {
+        const auto &block = chainB[i];
+        BOOST_REQUIRE(ProcessNewBlock(GetConfig(), block, true, nullptr));
+
+        const CBlockIndex *block_index;
+        {
+            LOCK(cs_main);
+            block_index = LookupBlockIndex(block->GetHash());
+        }
+
+        BOOST_CHECK(filter_index.BlockUntilSyncedToCurrentChain());
+        CheckFilterLookups(filter_index, block_index, chainB_last_header);
+    }
+
+    // Check that filters for stale blocks on A can be retrieved.
+    chainA_last_header = last_header;
+    for (size_t i = 0; i < 2; i++) {
+        const auto &block = chainA[i];
+        const CBlockIndex *block_index;
+        {
+            LOCK(cs_main);
+            block_index = LookupBlockIndex(block->GetHash());
+        }
+
+        BOOST_CHECK(filter_index.BlockUntilSyncedToCurrentChain());
+        CheckFilterLookups(filter_index, block_index, chainA_last_header);
+    }
+
+    // Reorg back to chain A.
+    for (size_t i = 2; i < 4; i++) {
+        const auto &block = chainA[i];
+        BOOST_REQUIRE(ProcessNewBlock(GetConfig(), block, true, nullptr));
+    }
+
+    // Check that chain A and B blocks can be retrieved.
+    chainA_last_header = last_header;
+    chainB_last_header = last_header;
+    for (size_t i = 0; i < 3; i++) {
+        const CBlockIndex *block_index;
+
+        {
+            LOCK(cs_main);
+            block_index = LookupBlockIndex(chainA[i]->GetHash());
+        }
+        BOOST_CHECK(filter_index.BlockUntilSyncedToCurrentChain());
+        CheckFilterLookups(filter_index, block_index, chainA_last_header);
+
+        {
+            LOCK(cs_main);
+            block_index = LookupBlockIndex(chainB[i]->GetHash());
+        }
+        BOOST_CHECK(filter_index.BlockUntilSyncedToCurrentChain());
+        CheckFilterLookups(filter_index, block_index, chainB_last_header);
     }
 
     // Test lookups for a range of filters/hashes.
     std::vector<BlockFilter> filters;
     std::vector<uint256> filter_hashes;
 
-    const CBlockIndex *block_index = ::ChainActive().Tip();
-    BOOST_CHECK(filter_index.LookupFilterRange(0, block_index, filters));
-    BOOST_CHECK(
-        filter_index.LookupFilterHashRange(0, block_index, filter_hashes));
+    {
+        LOCK(cs_main);
+        tip = ::ChainActive().Tip();
+    }
+    BOOST_CHECK(filter_index.LookupFilterRange(0, tip, filters));
+    BOOST_CHECK(filter_index.LookupFilterHashRange(0, tip, filter_hashes));
 
-    BOOST_CHECK_EQUAL(filters.size(), ::ChainActive().Height() + 1);
-    BOOST_CHECK_EQUAL(filter_hashes.size(), ::ChainActive().Height() + 1);
+    BOOST_CHECK_EQUAL(filters.size(), tip->nHeight + 1);
+    BOOST_CHECK_EQUAL(filter_hashes.size(), tip->nHeight + 1);
 
     filters.clear();
     filter_hashes.clear();
 
     filter_index.Interrupt();
     filter_index.Stop();
 }
 
 BOOST_AUTO_TEST_SUITE_END()