diff --git a/src/minerfund.h b/src/minerfund.h
--- a/src/minerfund.h
+++ b/src/minerfund.h
@@ -7,8 +7,9 @@
 
 #include <consensus/amount.h>
 #include <script/standard.h>
+#include <util/hasher.h>
 
-#include <vector>
+#include <unordered_set>
 
 class CBlockIndex;
 
@@ -18,7 +19,7 @@
 
 Amount GetMinerFundAmount(const Amount &coinbaseValue);
 
-std::vector<CTxDestination>
+std::unordered_set<CTxDestination, TxDestinationHasher>
 GetMinerFundWhitelist(const Consensus::Params &params,
                       const CBlockIndex *pindexPrev);
 
diff --git a/src/minerfund.cpp b/src/minerfund.cpp
--- a/src/minerfund.cpp
+++ b/src/minerfund.cpp
@@ -45,7 +45,7 @@
     return useAxionDestination ? destAxion : dest;
 }
 
-std::vector<CTxDestination>
+std::unordered_set<CTxDestination, TxDestinationHasher>
 GetMinerFundWhitelist(const Consensus::Params &params,
                       const CBlockIndex *pindexPrev) {
     if (!gArgs.GetBoolArg("-enableminerfund", params.enableMinerFund)) {
diff --git a/src/node/miner.cpp b/src/node/miner.cpp
--- a/src/node/miner.cpp
+++ b/src/node/miner.cpp
@@ -193,13 +193,12 @@
         nFees + GetBlockSubsidy(nHeight, consensusParams);
     coinbaseTx.vin[0].scriptSig = CScript() << nHeight << OP_0;
 
-    const std::vector<CTxDestination> whitelisted =
-        GetMinerFundWhitelist(consensusParams, pindexPrev);
+    const auto whitelisted = GetMinerFundWhitelist(consensusParams, pindexPrev);
     if (!whitelisted.empty()) {
         const Amount fund = GetMinerFundAmount(coinbaseTx.vout[0].nValue);
         coinbaseTx.vout[0].nValue -= fund;
-        coinbaseTx.vout.emplace_back(fund,
-                                     GetScriptForDestination(whitelisted[0]));
+        coinbaseTx.vout.emplace_back(
+            fund, GetScriptForDestination(*whitelisted.begin()));
     }
 
     // Make sure the coinbase is big enough.
diff --git a/src/test/CMakeLists.txt b/src/test/CMakeLists.txt
--- a/src/test/CMakeLists.txt
+++ b/src/test/CMakeLists.txt
@@ -165,6 +165,7 @@
 		fs_tests.cpp
 		getarg_tests.cpp
 		hash_tests.cpp
+		hasher_tests.cpp
 		i2p_tests.cpp
 		interfaces_tests.cpp
 		intmath_tests.cpp
diff --git a/src/test/hasher_tests.cpp b/src/test/hasher_tests.cpp
new file mode 100644
--- /dev/null
+++ b/src/test/hasher_tests.cpp
@@ -0,0 +1,36 @@
+// Copyright (c) 2023 The Bitcoin developers
+// Distributed under the MIT software license, see the accompanying
+// file COPYING or http://www.opensource.org/licenses/mit-license.php.
+
+#include <util/hasher.h>
+
+#include <test/util/setup_common.h>
+
+#include <boost/test/unit_test.hpp>
+
+BOOST_FIXTURE_TEST_SUITE(hasher_tests, BasicTestingSetup)
+
+BOOST_AUTO_TEST_CASE(hasher_txdestinationhasher) {
+    const auto hasher1 = TxDestinationHasher();
+    const auto hasher2 = TxDestinationHasher();
+
+    const std::vector<uint8_t> hash = {118, 160, 64,  83,  189, 160, 168,
+                                       139, 218, 81,  119, 184, 106, 21,
+                                       195, 178, 159, 85,  152, 115};
+
+    const CTxDestination dstNone = CNoDestination{};
+    const CTxDestination dstKey = PKHash(uint160(hash));
+    const CTxDestination dstScript = ScriptHash(uint160(hash));
+
+    // A hasher should return the same hash for a given tx destination
+    BOOST_CHECK(hasher1(dstNone) == hasher1(CNoDestination{}));
+    BOOST_CHECK(hasher1(dstKey) == hasher1(PKHash(uint160(hash))));
+    BOOST_CHECK(hasher1(dstScript) == hasher1(ScriptHash(uint160(hash))));
+
+    // Two hashers should not return the same output for given input
+    BOOST_CHECK(hasher1(dstNone) != hasher2(dstNone));
+    BOOST_CHECK(hasher1(dstKey) != hasher2(dstKey));
+    BOOST_CHECK(hasher1(dstScript) != hasher2(dstScript));
+}
+
+BOOST_AUTO_TEST_SUITE_END()
diff --git a/src/test/minerfund_tests.cpp b/src/test/minerfund_tests.cpp
--- a/src/test/minerfund_tests.cpp
+++ b/src/test/minerfund_tests.cpp
@@ -14,6 +14,18 @@
 
 BOOST_FIXTURE_TEST_SUITE(minerfund_tests, BasicTestingSetup)
 
+static void
+CheckWhitelist(const Consensus::Params &consensusParams,
+               const CBlockIndex *pindexPrev,
+               const std::unordered_set<CTxDestination, TxDestinationHasher>
+                   expectedWhitelist) {
+    auto whitelist = GetMinerFundWhitelist(consensusParams, pindexPrev);
+    BOOST_CHECK_EQUAL(whitelist.size(), expectedWhitelist.size());
+    for (const auto &expectedDest : expectedWhitelist) {
+        BOOST_CHECK_EQUAL(whitelist.count(expectedDest), 1);
+    }
+}
+
 BOOST_AUTO_TEST_CASE(minerfund_whitelist) {
     const CChainParams &chainparams = Params();
     const Consensus::Params &consensusParams = chainparams.GetConsensus();
@@ -21,29 +33,28 @@
     CBlockIndex block;
 
     // Consensus whitelist has not activated yet
-    const std::vector<CTxDestination> emptyWhitelist;
+    const std::unordered_set<CTxDestination, TxDestinationHasher>
+        emptyWhitelist;
     block.nHeight = consensusParams.axionHeight - 1;
-    BOOST_CHECK(GetMinerFundWhitelist(consensusParams, &block) ==
-                emptyWhitelist);
+    CheckWhitelist(consensusParams, &block, emptyWhitelist);
 
     // Axion whitelist is active
-    const std::vector<CTxDestination> expectedAxion = {DecodeDestination(
-        "ecash:pqnqv9lt7e5vjyp0w88zf2af0l92l8rxdg2jj94l5j", chainparams)};
+    const std::unordered_set<CTxDestination, TxDestinationHasher>
+        expectedAxion = {DecodeDestination(
+            "ecash:pqnqv9lt7e5vjyp0w88zf2af0l92l8rxdg2jj94l5j", chainparams)};
     block.nHeight = consensusParams.axionHeight;
-    BOOST_CHECK(GetMinerFundWhitelist(consensusParams, &block) ==
-                expectedAxion);
+    CheckWhitelist(consensusParams, &block, expectedAxion);
 
     // Does not change up to Gluon activation
     block.nHeight = consensusParams.gluonHeight - 1;
-    BOOST_CHECK(GetMinerFundWhitelist(consensusParams, &block) ==
-                expectedAxion);
+    CheckWhitelist(consensusParams, &block, expectedAxion);
 
     // Miner fund address changed with Gluon
-    const std::vector<CTxDestination> expectedMinerFund = {DecodeDestination(
-        "ecash:prfhcnyqnl5cgrnmlfmms675w93ld7mvvqd0y8lz07", chainparams)};
+    const std::unordered_set<CTxDestination, TxDestinationHasher>
+        expectedMinerFund = {DecodeDestination(
+            "ecash:prfhcnyqnl5cgrnmlfmms675w93ld7mvvqd0y8lz07", chainparams)};
     block.nHeight = consensusParams.gluonHeight;
-    BOOST_CHECK(GetMinerFundWhitelist(consensusParams, &block) ==
-                expectedMinerFund);
+    CheckWhitelist(consensusParams, &block, expectedMinerFund);
 }
 
 BOOST_AUTO_TEST_SUITE_END()
diff --git a/src/util/hasher.h b/src/util/hasher.h
--- a/src/util/hasher.h
+++ b/src/util/hasher.h
@@ -9,6 +9,7 @@
 #include <primitives/blockhash.h>
 #include <primitives/transaction.h>
 #include <primitives/txid.h>
+#include <script/standard.h>
 #include <uint256.h>
 
 class SaltedUint256Hasher {
@@ -102,4 +103,10 @@
     size_t operator()(const Span<const uint8_t> &script) const;
 };
 
+struct TxDestinationHasher : SaltedSipHasher {
+    size_t operator()(const CTxDestination &dest) const {
+        return SaltedSipHasher::operator()(GetScriptForDestination(dest));
+    }
+};
+
 #endif // BITCOIN_UTIL_HASHER_H
diff --git a/src/validation.cpp b/src/validation.cpp
--- a/src/validation.cpp
+++ b/src/validation.cpp
@@ -2145,7 +2145,7 @@
                              "bad-cb-amount");
     }
 
-    const std::vector<CTxDestination> whitelist =
+    const auto whitelist =
         GetMinerFundWhitelist(consensusParams, pindex->pprev);
     if (!whitelist.empty()) {
         const Amount required = GetMinerFundAmount(blockReward);