diff --git a/src/bench/gcs_filter.cpp b/src/bench/gcs_filter.cpp
index 89fa07f602..56f3cff0c1 100644
--- a/src/bench/gcs_filter.cpp
+++ b/src/bench/gcs_filter.cpp
@@ -52,7 +52,7 @@ static void DecodeGCSFilter(benchmark::Bench& bench)
     auto encoded = filter.GetEncoded();
 
     bench.unit("elem").run([&] {
-        GCSFilter filter({0, 0, BASIC_FILTER_P, BASIC_FILTER_M}, encoded);
+        GCSFilter filter({0, 0, BASIC_FILTER_P, BASIC_FILTER_M}, encoded, /*filter_checked=*/false);
     });
 }
 
@@ -66,7 +66,7 @@ static void BlockFilterGetHash(benchmark::Bench& bench)
         elements.insert(std::move(element));
     }
     GCSFilter filter({0, 0, BASIC_FILTER_P, BASIC_FILTER_M}, elements);
-    BlockFilter block_filter(BlockFilterType::BASIC, {}, filter.GetEncoded());
+    BlockFilter block_filter(BlockFilterType::BASIC, {}, filter.GetEncoded(), /*filter_checked=*/false);
 
     bench.unit("elem").run([&] {
         block_filter.GetHash();
@@ -86,7 +86,7 @@ static void DecodeCheckedGCSFilter(benchmark::Bench& bench)
     auto encoded = filter.GetEncoded();
 
     bench.unit("elem").run([&] {
-        GCSFilter filter({0, 0, BASIC_FILTER_P, BASIC_FILTER_M}, encoded, true);
+        GCSFilter filter({0, 0, BASIC_FILTER_P, BASIC_FILTER_M}, encoded, /*filter_checked=*/true);
     });
 }
 BENCHMARK(BlockFilterGetHash);
diff --git a/src/blockfilter.h b/src/blockfilter.h
index 21d6a295a2..f823354989 100644
--- a/src/blockfilter.h
+++ b/src/blockfilter.h
@@ -59,7 +59,7 @@ public:
     explicit GCSFilter(const Params& params = Params());
 
     /** Reconstructs an already-created filter from an encoding. */
-    GCSFilter(const Params& params, std::vector<unsigned char> encoded_filter, bool filter_checked=false);
+    GCSFilter(const Params& params, std::vector<unsigned char> encoded_filter, bool filter_checked);
 
     /** Builds a new filter from the params and set of elements. */
     GCSFilter(const Params& params, const ElementSet& elements);
@@ -122,7 +122,7 @@ public:
 
     //! Reconstruct a BlockFilter from parts.
     BlockFilter(BlockFilterType filter_type, const uint256& block_hash,
-                std::vector<unsigned char> filter, bool filter_checked=false);
+                std::vector<unsigned char> filter, bool filter_checked);
 
     //! Construct a new BlockFilter of the specified type from a block.
     BlockFilter(BlockFilterType filter_type, const CBlock& block, const CBlockUndo& block_undo);
@@ -164,7 +164,7 @@ public:
         if (!BuildParams(params)) {
             throw std::ios_base::failure("unknown filter_type");
         }
-        m_filter = GCSFilter(params, std::move(encoded_filter));
+        m_filter = GCSFilter(params, std::move(encoded_filter), /*filter_checked=*/false);
     }
 };

diff --git a/src/blockfilter.h b/src/blockfilter.h
index 21d6a295a2..764395c370 100644
--- a/src/blockfilter.h
+++ b/src/blockfilter.h
@@ -148,24 +148,6 @@ public:
           << m_block_hash
           << m_filter.GetEncoded();
     }
-
-    template <typename Stream>
-    void Unserialize(Stream& s) {
-        std::vector<unsigned char> encoded_filter;
-        uint8_t filter_type;
-
-        s >> filter_type
-          >> m_block_hash
-          >> encoded_filter;
-
-        m_filter_type = static_cast<BlockFilterType>(filter_type);
-
-        GCSFilter::Params params;
-        if (!BuildParams(params)) {
-            throw std::ios_base::failure("unknown filter_type");
-        }
-        m_filter = GCSFilter(params, std::move(encoded_filter));
-    }
 };
 
 #endif // BITCOIN_BLOCKFILTER_H
diff --git a/src/test/blockfilter_tests.cpp b/src/test/blockfilter_tests.cpp
index 8eb4dbc592..b99d9a32c3 100644
--- a/src/test/blockfilter_tests.cpp
+++ b/src/test/blockfilter_tests.cpp
@@ -106,23 +106,6 @@ BOOST_AUTO_TEST_CASE(blockfilter_basic_test)
     for (const CScript& script : excluded_scripts) {
         BOOST_CHECK(!filter.Match(GCSFilter::Element(script.begin(), script.end())));
     }
-
-    // Test serialization/unserialization.
-    BlockFilter block_filter2;
-
-    CDataStream stream(SER_NETWORK, PROTOCOL_VERSION);
-    stream << block_filter;
-    stream >> block_filter2;
-
-    BOOST_CHECK_EQUAL(block_filter.GetFilterType(), block_filter2.GetFilterType());
-    BOOST_CHECK_EQUAL(block_filter.GetBlockHash(), block_filter2.GetBlockHash());
-    BOOST_CHECK(block_filter.GetEncodedFilter() == block_filter2.GetEncodedFilter());
-
-    BlockFilter default_ctor_block_filter_1;
-    BlockFilter default_ctor_block_filter_2;
-    BOOST_CHECK_EQUAL(default_ctor_block_filter_1.GetFilterType(), default_ctor_block_filter_2.GetFilterType());
-    BOOST_CHECK_EQUAL(default_ctor_block_filter_1.GetBlockHash(), default_ctor_block_filter_2.GetBlockHash());
-    BOOST_CHECK(default_ctor_block_filter_1.GetEncodedFilter() == default_ctor_block_filter_2.GetEncodedFilter());
 }
 
 BOOST_AUTO_TEST_CASE(blockfilters_json_test)
diff --git a/src/test/fuzz/deserialize.cpp b/src/test/fuzz/deserialize.cpp
index ed6f172a2a..3793921e86 100644
--- a/src/test/fuzz/deserialize.cpp
+++ b/src/test/fuzz/deserialize.cpp
@@ -95,12 +95,6 @@ void DeserializeFromFuzzingInput(FuzzBufferType buffer, T& obj, const std::optio
             throw invalid_fuzzing_input_exception();
         }
     }
-    try {
-        ds >> obj;
-    } catch (const std::ios_base::failure&) {
-        throw invalid_fuzzing_input_exception();
-    }
-    assert(buffer.empty() || !Serialize(obj).empty());
 }
 
 template <typename T>
diff --git a/src/test/fuzz/util.h b/src/test/fuzz/util.h
index 6c91844633..e8e8e57394 100644
--- a/src/test/fuzz/util.h
+++ b/src/test/fuzz/util.h
@@ -145,11 +145,6 @@ template <typename T>
     const std::vector<uint8_t> buffer = ConsumeRandomLengthByteVector(fuzzed_data_provider, max_length);
     CDataStream ds{buffer, SER_NETWORK, INIT_PROTO_VERSION};
     T obj;
-    try {
-        ds >> obj;
-    } catch (const std::ios_base::failure&) {
-        return std::nullopt;
-    }
     return obj;
 }

diff --git a/src/blockfilter.cpp b/src/blockfilter.cpp
index 08e2e6f72e..9d76d2b60e 100644
--- a/src/blockfilter.cpp
+++ b/src/blockfilter.cpp
@@ -59,7 +59,7 @@ GCSFilter::GCSFilter(const Params& params, std::vector<unsigned char> encoded_fi
     }
     m_F = static_cast<uint64_t>(m_N) * static_cast<uint64_t>(m_params.m_M);
 
-    if (filter_checked) return;
+    // if (filter_checked) return;
 
     // Verify that the encoded filter contains exactly N elements. If it has too much or too little
     // data, a std::ios_base::failure exception will be raised.
diff --git a/src/index/blockfilterindex.cpp b/src/index/blockfilterindex.cpp
index 1471c29a85..f83b883c8f 100644
--- a/src/index/blockfilterindex.cpp
+++ b/src/index/blockfilterindex.cpp
@@ -156,9 +156,6 @@ bool BlockFilterIndex::ReadFilterFromDisk(const FlatFilePos& pos, const uint256&
     std::vector<uint8_t> encoded_filter;
     try {
         filein >> block_hash >> encoded_filter;
-        uint256 result;
-        CHash256().Write(encoded_filter).Finalize(result);
-        if (result != hash) return error("Checksum mismatch in filter decode.");
         filter = BlockFilter(GetFilterType(), block_hash, std::move(encoded_filter), /*filter_checked=*/true);