diff --git a/src/avalanche/proofbuilder.cpp b/src/avalanche/proofbuilder.cpp
index 9227ab16d..6e618e579 100644
--- a/src/avalanche/proofbuilder.cpp
+++ b/src/avalanche/proofbuilder.cpp
@@ -1,73 +1,67 @@
 // Copyright (c) 2020 The Bitcoin developers
 // Distributed under the MIT software license, see the accompanying
 // file COPYING or http://www.opensource.org/licenses/mit-license.php.
 
 #include <avalanche/proofbuilder.h>
 
 #include <random.h>
 
 namespace avalanche {
 
 SignedStake ProofBuilder::StakeSigner::sign(const ProofId &proofid) {
     const uint256 h = stake.getHash(proofid);
 
     SchnorrSig sig;
     if (!key.SignSchnorr(h, sig)) {
         sig.fill(0);
     }
 
     return SignedStake(std::move(stake), std::move(sig));
 }
 
 bool ProofBuilder::addUTXO(COutPoint utxo, Amount amount, uint32_t height,
                            bool is_coinbase, CKey key) {
     if (!key.IsValid()) {
         return false;
     }
 
-    stakes.emplace_back(
-        Stake(std::move(utxo), amount, height, is_coinbase, key.GetPubKey()),
-        std::move(key));
-    return true;
+    return stakes
+        .emplace(Stake(std::move(utxo), amount, height, is_coinbase,
+                       key.GetPubKey()),
+                 std::move(key))
+        .second;
 }
 
 Proof ProofBuilder::build() {
     const ProofId proofid = getProofId();
 
     std::vector<SignedStake> signedStakes;
     signedStakes.reserve(stakes.size());
 
-    for (auto &s : stakes) {
-        signedStakes.push_back(s.sign(proofid));
+    while (!stakes.empty()) {
+        auto handle = stakes.extract(stakes.begin());
+        signedStakes.push_back(handle.value().sign(proofid));
     }
 
-    stakes.clear();
     return Proof(sequence, expirationTime, std::move(master),
                  std::move(signedStakes));
 }
 
-ProofId ProofBuilder::getProofId() {
+ProofId ProofBuilder::getProofId() const {
     CHashWriter ss(SER_GETHASH, 0);
     ss << sequence;
     ss << expirationTime;
 
-    // TODO This can be avoided by using a sorted container instead of a vector
-    // for the stakes.
-    std::sort(stakes.begin(), stakes.end(),
-              [](const StakeSigner &lhs, const StakeSigner &rhs) {
-                  return lhs.stake.getId() < rhs.stake.getId();
-              });
-
     WriteCompactSize(ss, stakes.size());
     for (const auto &s : stakes) {
         ss << s.stake;
     }
 
     CHashWriter ss2(SER_GETHASH, 0);
     ss2 << ss.GetHash();
     ss2 << master;
 
     return ProofId(ss2.GetHash());
 }
 
 } // namespace avalanche
diff --git a/src/avalanche/proofbuilder.h b/src/avalanche/proofbuilder.h
index 777fe4454..4a56ab4ec 100644
--- a/src/avalanche/proofbuilder.h
+++ b/src/avalanche/proofbuilder.h
@@ -1,52 +1,57 @@
 // Copyright (c) 2020 The Bitcoin developers
 // Distributed under the MIT software license, see the accompanying
 // file COPYING or http://www.opensource.org/licenses/mit-license.php.
 
 #ifndef BITCOIN_AVALANCHE_PROOFBUILDER_H
 #define BITCOIN_AVALANCHE_PROOFBUILDER_H
 
 #include <avalanche/proof.h>
 #include <key.h>
 
 #include <cstdio>
 
 namespace avalanche {
 
 struct TestProofBuilder;
 
 class ProofBuilder {
     uint64_t sequence;
     int64_t expirationTime;
     CPubKey master;
 
     struct StakeSigner {
         Stake stake;
         CKey key;
 
         StakeSigner(Stake stake_, CKey key_)
             : stake(std::move(stake_)), key(std::move(key_)) {}
 
         SignedStake sign(const ProofId &proofid);
     };
 
-    std::vector<StakeSigner> stakes;
+    struct StakeSignerComparator {
+        bool operator()(const StakeSigner &lhs, const StakeSigner &rhs) const {
+            return lhs.stake.getId() < rhs.stake.getId();
+        }
+    };
+    std::set<StakeSigner, StakeSignerComparator> stakes;
 
 public:
     ProofBuilder(uint64_t sequence_, int64_t expirationTime_, CPubKey master_)
         : sequence(sequence_), expirationTime(expirationTime_),
           master(std::move(master_)) {}
 
     bool addUTXO(COutPoint utxo, Amount amount, uint32_t height,
                  bool is_coinbase, CKey key);
 
     Proof build();
 
 private:
-    ProofId getProofId();
+    ProofId getProofId() const;
 
     friend struct TestProofBuilder;
 };
 
 } // namespace avalanche
 
 #endif // BITCOIN_AVALANCHE_PROOFBUILDER_H
diff --git a/src/avalanche/test/peermanager_tests.cpp b/src/avalanche/test/peermanager_tests.cpp
index 1be7499ee..d8affb7bb 100644
--- a/src/avalanche/test/peermanager_tests.cpp
+++ b/src/avalanche/test/peermanager_tests.cpp
@@ -1,791 +1,797 @@
 // Copyright (c) 2020 The Bitcoin developers
 // Distributed under the MIT software license, see the accompanying
 // file COPYING or http://www.opensource.org/licenses/mit-license.php.
 
 #include <avalanche/delegationbuilder.h>
 #include <avalanche/peermanager.h>
 #include <avalanche/proofbuilder.h>
 #include <avalanche/test/util.h>
 #include <script/standard.h>
 #include <validation.h>
 
 #include <test/util/setup_common.h>
 
 #include <boost/test/unit_test.hpp>
 
 using namespace avalanche;
 
 namespace avalanche {
 namespace {
     struct TestPeerManager {
         static bool nodeBelongToPeer(const PeerManager &pm, NodeId nodeid,
                                      PeerId peerid) {
             return pm.forNode(nodeid, [&](const Node &node) {
                 return node.peerid == peerid;
             });
         }
 
         static bool isNodePending(const PeerManager &pm, NodeId nodeid) {
             auto &pendingNodesView = pm.pendingNodes.get<by_nodeid>();
             return pendingNodesView.find(nodeid) != pendingNodesView.end();
         }
     };
 } // namespace
 } // namespace avalanche
 
 BOOST_FIXTURE_TEST_SUITE(peermanager_tests, TestingSetup)
 
 BOOST_AUTO_TEST_CASE(select_peer_linear) {
     // No peers.
     BOOST_CHECK_EQUAL(selectPeerImpl({}, 0, 0), NO_PEER);
     BOOST_CHECK_EQUAL(selectPeerImpl({}, 1, 3), NO_PEER);
 
     // One peer
     const std::vector<Slot> oneslot = {{100, 100, 23}};
 
     // Undershoot
     BOOST_CHECK_EQUAL(selectPeerImpl(oneslot, 0, 300), NO_PEER);
     BOOST_CHECK_EQUAL(selectPeerImpl(oneslot, 42, 300), NO_PEER);
     BOOST_CHECK_EQUAL(selectPeerImpl(oneslot, 99, 300), NO_PEER);
 
     // Nailed it
     BOOST_CHECK_EQUAL(selectPeerImpl(oneslot, 100, 300), 23);
     BOOST_CHECK_EQUAL(selectPeerImpl(oneslot, 142, 300), 23);
     BOOST_CHECK_EQUAL(selectPeerImpl(oneslot, 199, 300), 23);
 
     // Overshoot
     BOOST_CHECK_EQUAL(selectPeerImpl(oneslot, 200, 300), NO_PEER);
     BOOST_CHECK_EQUAL(selectPeerImpl(oneslot, 242, 300), NO_PEER);
     BOOST_CHECK_EQUAL(selectPeerImpl(oneslot, 299, 300), NO_PEER);
 
     // Two peers
     const std::vector<Slot> twoslots = {{100, 100, 69}, {300, 100, 42}};
 
     // Undershoot
     BOOST_CHECK_EQUAL(selectPeerImpl(twoslots, 0, 500), NO_PEER);
     BOOST_CHECK_EQUAL(selectPeerImpl(twoslots, 42, 500), NO_PEER);
     BOOST_CHECK_EQUAL(selectPeerImpl(twoslots, 99, 500), NO_PEER);
 
     // First entry
     BOOST_CHECK_EQUAL(selectPeerImpl(twoslots, 100, 500), 69);
     BOOST_CHECK_EQUAL(selectPeerImpl(twoslots, 142, 500), 69);
     BOOST_CHECK_EQUAL(selectPeerImpl(twoslots, 199, 500), 69);
 
     // In between
     BOOST_CHECK_EQUAL(selectPeerImpl(twoslots, 200, 500), NO_PEER);
     BOOST_CHECK_EQUAL(selectPeerImpl(twoslots, 242, 500), NO_PEER);
     BOOST_CHECK_EQUAL(selectPeerImpl(twoslots, 299, 500), NO_PEER);
 
     // Second entry
     BOOST_CHECK_EQUAL(selectPeerImpl(twoslots, 300, 500), 42);
     BOOST_CHECK_EQUAL(selectPeerImpl(twoslots, 342, 500), 42);
     BOOST_CHECK_EQUAL(selectPeerImpl(twoslots, 399, 500), 42);
 
     // Overshoot
     BOOST_CHECK_EQUAL(selectPeerImpl(twoslots, 400, 500), NO_PEER);
     BOOST_CHECK_EQUAL(selectPeerImpl(twoslots, 442, 500), NO_PEER);
     BOOST_CHECK_EQUAL(selectPeerImpl(twoslots, 499, 500), NO_PEER);
 }
 
 BOOST_AUTO_TEST_CASE(select_peer_dichotomic) {
     std::vector<Slot> slots;
 
     // 100 peers of size 1 with 1 empty element apart.
     uint64_t max = 1;
     for (int i = 0; i < 100; i++) {
         slots.emplace_back(max, 1, i);
         max += 2;
     }
 
     BOOST_CHECK_EQUAL(selectPeerImpl(slots, 4, max), NO_PEER);
 
     // Check that we get what we expect.
     for (int i = 0; i < 100; i++) {
         BOOST_CHECK_EQUAL(selectPeerImpl(slots, 2 * i, max), NO_PEER);
         BOOST_CHECK_EQUAL(selectPeerImpl(slots, 2 * i + 1, max), i);
     }
 
     BOOST_CHECK_EQUAL(selectPeerImpl(slots, max, max), NO_PEER);
 
     // Update the slots to be heavily skewed toward the last element.
     slots[99] = slots[99].withScore(101);
     max = slots[99].getStop();
     BOOST_CHECK_EQUAL(max, 300);
 
     for (int i = 0; i < 100; i++) {
         BOOST_CHECK_EQUAL(selectPeerImpl(slots, 2 * i, max), NO_PEER);
         BOOST_CHECK_EQUAL(selectPeerImpl(slots, 2 * i + 1, max), i);
     }
 
     BOOST_CHECK_EQUAL(selectPeerImpl(slots, 200, max), 99);
     BOOST_CHECK_EQUAL(selectPeerImpl(slots, 256, max), 99);
     BOOST_CHECK_EQUAL(selectPeerImpl(slots, 299, max), 99);
     BOOST_CHECK_EQUAL(selectPeerImpl(slots, 300, max), NO_PEER);
 
     // Update the slots to be heavily skewed toward the first element.
     for (int i = 0; i < 100; i++) {
         slots[i] = slots[i].withStart(slots[i].getStart() + 100);
     }
 
     slots[0] = Slot(1, slots[0].getStop() - 1, slots[0].getPeerId());
     slots[99] = slots[99].withScore(1);
     max = slots[99].getStop();
     BOOST_CHECK_EQUAL(max, 300);
 
     BOOST_CHECK_EQUAL(selectPeerImpl(slots, 0, max), NO_PEER);
     BOOST_CHECK_EQUAL(selectPeerImpl(slots, 1, max), 0);
     BOOST_CHECK_EQUAL(selectPeerImpl(slots, 42, max), 0);
 
     for (int i = 0; i < 100; i++) {
         BOOST_CHECK_EQUAL(selectPeerImpl(slots, 100 + 2 * i + 1, max), i);
         BOOST_CHECK_EQUAL(selectPeerImpl(slots, 100 + 2 * i + 2, max), NO_PEER);
     }
 }
 
 BOOST_AUTO_TEST_CASE(select_peer_random) {
     for (int c = 0; c < 1000; c++) {
         size_t size = InsecureRandBits(10) + 1;
         std::vector<Slot> slots;
         slots.reserve(size);
 
         uint64_t max = InsecureRandBits(3);
         auto next = [&]() {
             uint64_t r = max;
             max += InsecureRandBits(3);
             return r;
         };
 
         for (size_t i = 0; i < size; i++) {
             const uint64_t start = next();
             const uint32_t score = InsecureRandBits(3);
             max += score;
             slots.emplace_back(start, score, i);
         }
 
         for (int k = 0; k < 100; k++) {
             uint64_t s = max > 0 ? InsecureRandRange(max) : 0;
             auto i = selectPeerImpl(slots, s, max);
             // /!\ Because of the way we construct the vector, the peer id is
             // always the index. This might not be the case in practice.
             BOOST_CHECK(i == NO_PEER || slots[i].contains(s));
         }
     }
 }
 
 static std::shared_ptr<Proof> getRandomProofPtr(uint32_t score) {
     return std::make_shared<Proof>(buildRandomProof(score));
 }
 
 static void addNodeWithScore(avalanche::PeerManager &pm, NodeId node,
                              uint32_t score) {
     auto proof = getRandomProofPtr(score);
     BOOST_CHECK_NE(pm.getPeerId(proof), NO_PEER);
     BOOST_CHECK(pm.addNode(node, proof->getId()));
 };
 
 BOOST_AUTO_TEST_CASE(peer_probabilities) {
     // No peers.
     avalanche::PeerManager pm;
     BOOST_CHECK_EQUAL(pm.selectNode(), NO_NODE);
 
     const NodeId node0 = 42, node1 = 69, node2 = 37;
 
     // One peer, we always return it.
     addNodeWithScore(pm, node0, MIN_VALID_PROOF_SCORE);
     BOOST_CHECK_EQUAL(pm.selectNode(), node0);
 
     // Two peers, verify ratio.
     addNodeWithScore(pm, node1, 2 * MIN_VALID_PROOF_SCORE);
 
     std::unordered_map<PeerId, int> results = {};
     for (int i = 0; i < 10000; i++) {
         size_t n = pm.selectNode();
         BOOST_CHECK(n == node0 || n == node1);
         results[n]++;
     }
 
     BOOST_CHECK(abs(2 * results[0] - results[1]) < 500);
 
     // Three peers, verify ratio.
     addNodeWithScore(pm, node2, MIN_VALID_PROOF_SCORE);
 
     results.clear();
     for (int i = 0; i < 10000; i++) {
         size_t n = pm.selectNode();
         BOOST_CHECK(n == node0 || n == node1 || n == node2);
         results[n]++;
     }
 
     BOOST_CHECK(abs(results[0] - results[1] + results[2]) < 500);
 }
 
 BOOST_AUTO_TEST_CASE(remove_peer) {
     // No peers.
     avalanche::PeerManager pm;
     BOOST_CHECK_EQUAL(pm.selectPeer(), NO_PEER);
 
     // Add 4 peers.
     std::array<PeerId, 8> peerids;
     for (int i = 0; i < 4; i++) {
         auto p = getRandomProofPtr(100);
         peerids[i] = pm.getPeerId(p);
         BOOST_CHECK(pm.addNode(InsecureRand32(), p->getId()));
     }
 
     BOOST_CHECK_EQUAL(pm.getSlotCount(), 400);
     BOOST_CHECK_EQUAL(pm.getFragmentation(), 0);
 
     for (int i = 0; i < 100; i++) {
         PeerId p = pm.selectPeer();
         BOOST_CHECK(p == peerids[0] || p == peerids[1] || p == peerids[2] ||
                     p == peerids[3]);
     }
 
     // Remove one peer, it nevers show up now.
     BOOST_CHECK(pm.removePeer(peerids[2]));
     BOOST_CHECK_EQUAL(pm.getSlotCount(), 400);
     BOOST_CHECK_EQUAL(pm.getFragmentation(), 100);
 
     // Make sure we compact to never get NO_PEER.
     BOOST_CHECK_EQUAL(pm.compact(), 100);
     BOOST_CHECK(pm.verify());
     BOOST_CHECK_EQUAL(pm.getSlotCount(), 300);
     BOOST_CHECK_EQUAL(pm.getFragmentation(), 0);
 
     for (int i = 0; i < 100; i++) {
         PeerId p = pm.selectPeer();
         BOOST_CHECK(p == peerids[0] || p == peerids[1] || p == peerids[3]);
     }
 
     // Add 4 more peers.
     for (int i = 0; i < 4; i++) {
         auto p = getRandomProofPtr(100);
         peerids[i + 4] = pm.getPeerId(p);
         BOOST_CHECK(pm.addNode(InsecureRand32(), p->getId()));
     }
 
     BOOST_CHECK_EQUAL(pm.getSlotCount(), 700);
     BOOST_CHECK_EQUAL(pm.getFragmentation(), 0);
 
     BOOST_CHECK(pm.removePeer(peerids[0]));
     BOOST_CHECK_EQUAL(pm.getSlotCount(), 700);
     BOOST_CHECK_EQUAL(pm.getFragmentation(), 100);
 
     // Removing the last entry do not increase fragmentation.
     BOOST_CHECK(pm.removePeer(peerids[7]));
     BOOST_CHECK_EQUAL(pm.getSlotCount(), 600);
     BOOST_CHECK_EQUAL(pm.getFragmentation(), 100);
 
     // Make sure we compact to never get NO_PEER.
     BOOST_CHECK_EQUAL(pm.compact(), 100);
     BOOST_CHECK(pm.verify());
     BOOST_CHECK_EQUAL(pm.getSlotCount(), 500);
     BOOST_CHECK_EQUAL(pm.getFragmentation(), 0);
 
     for (int i = 0; i < 100; i++) {
         PeerId p = pm.selectPeer();
         BOOST_CHECK(p == peerids[1] || p == peerids[3] || p == peerids[4] ||
                     p == peerids[5] || p == peerids[6]);
     }
 
     // Removing non existent peers fails.
     BOOST_CHECK(!pm.removePeer(peerids[0]));
     BOOST_CHECK(!pm.removePeer(peerids[2]));
     BOOST_CHECK(!pm.removePeer(peerids[7]));
     BOOST_CHECK(!pm.removePeer(NO_PEER));
 }
 
 BOOST_AUTO_TEST_CASE(compact_slots) {
     avalanche::PeerManager pm;
 
     // Add 4 peers.
     std::array<PeerId, 4> peerids;
     for (int i = 0; i < 4; i++) {
         auto p = getRandomProofPtr(100);
         peerids[i] = pm.getPeerId(p);
         BOOST_CHECK(pm.addNode(InsecureRand32(), p->getId()));
     }
 
     // Remove all peers.
     for (auto p : peerids) {
         pm.removePeer(p);
     }
 
     BOOST_CHECK_EQUAL(pm.getSlotCount(), 300);
     BOOST_CHECK_EQUAL(pm.getFragmentation(), 300);
 
     for (int i = 0; i < 100; i++) {
         BOOST_CHECK_EQUAL(pm.selectPeer(), NO_PEER);
     }
 
     BOOST_CHECK_EQUAL(pm.compact(), 300);
     BOOST_CHECK(pm.verify());
     BOOST_CHECK_EQUAL(pm.getSlotCount(), 0);
     BOOST_CHECK_EQUAL(pm.getFragmentation(), 0);
 }
 
 BOOST_AUTO_TEST_CASE(node_crud) {
     avalanche::PeerManager pm;
 
     // Create one peer.
     auto proof = getRandomProofPtr(10000000 * MIN_VALID_PROOF_SCORE);
     BOOST_CHECK_NE(pm.getPeerId(proof), NO_PEER);
     BOOST_CHECK_EQUAL(pm.selectNode(), NO_NODE);
 
     // Add 4 nodes.
     const ProofId &proofid = proof->getId();
     for (int i = 0; i < 4; i++) {
         BOOST_CHECK(pm.addNode(i, proofid));
     }
 
     for (int i = 0; i < 100; i++) {
         NodeId n = pm.selectNode();
         BOOST_CHECK(n >= 0 && n < 4);
         BOOST_CHECK(
             pm.updateNextRequestTime(n, std::chrono::steady_clock::now()));
     }
 
     // Remove a node, check that it doesn't show up.
     BOOST_CHECK(pm.removeNode(2));
 
     for (int i = 0; i < 100; i++) {
         NodeId n = pm.selectNode();
         BOOST_CHECK(n == 0 || n == 1 || n == 3);
         BOOST_CHECK(
             pm.updateNextRequestTime(n, std::chrono::steady_clock::now()));
     }
 
     // Push a node's timeout in the future, so that it doesn't show up.
     BOOST_CHECK(pm.updateNextRequestTime(1, std::chrono::steady_clock::now() +
                                                 std::chrono::hours(24)));
 
     for (int i = 0; i < 100; i++) {
         NodeId n = pm.selectNode();
         BOOST_CHECK(n == 0 || n == 3);
         BOOST_CHECK(
             pm.updateNextRequestTime(n, std::chrono::steady_clock::now()));
     }
 
     // Move a node from a peer to another. This peer has a very low score such
     // as chances of being picked are 1 in 10 million.
     addNodeWithScore(pm, 3, MIN_VALID_PROOF_SCORE);
 
     int node3selected = 0;
     for (int i = 0; i < 100; i++) {
         NodeId n = pm.selectNode();
         if (n == 3) {
             // Selecting this node should be exceedingly unlikely.
             BOOST_CHECK(node3selected++ < 1);
         } else {
             BOOST_CHECK_EQUAL(n, 0);
         }
         BOOST_CHECK(
             pm.updateNextRequestTime(n, std::chrono::steady_clock::now()));
     }
 }
 
 BOOST_AUTO_TEST_CASE(node_binding) {
     avalanche::PeerManager pm;
 
     auto proof = getRandomProofPtr(MIN_VALID_PROOF_SCORE);
     const ProofId &proofid = proof->getId();
 
     // Add a bunch of nodes with no associated peer
     for (int i = 0; i < 10; i++) {
         BOOST_CHECK(!pm.addNode(i, proofid));
         BOOST_CHECK(TestPeerManager::isNodePending(pm, i));
     }
 
     // Now create the peer and check all the nodes are bound
     const PeerId peerid = pm.getPeerId(proof);
     BOOST_CHECK_NE(peerid, NO_PEER);
     for (int i = 0; i < 10; i++) {
         BOOST_CHECK(!TestPeerManager::isNodePending(pm, i));
         BOOST_CHECK(TestPeerManager::nodeBelongToPeer(pm, i, peerid));
     }
     BOOST_CHECK(pm.verify());
 
     // Disconnect some nodes
     for (int i = 0; i < 5; i++) {
         BOOST_CHECK(pm.removeNode(i));
         BOOST_CHECK(!TestPeerManager::isNodePending(pm, i));
         BOOST_CHECK(!TestPeerManager::nodeBelongToPeer(pm, i, peerid));
     }
 
     // Add nodes when the peer already exists
     for (int i = 0; i < 5; i++) {
         BOOST_CHECK(pm.addNode(i, proofid));
         BOOST_CHECK(!TestPeerManager::isNodePending(pm, i));
         BOOST_CHECK(TestPeerManager::nodeBelongToPeer(pm, i, peerid));
     }
 
     auto alt_proof = getRandomProofPtr(MIN_VALID_PROOF_SCORE);
     const ProofId &alt_proofid = alt_proof->getId();
 
     // Update some nodes from a known proof to an unknown proof
     for (int i = 0; i < 5; i++) {
         BOOST_CHECK(!pm.addNode(i, alt_proofid));
         BOOST_CHECK(TestPeerManager::isNodePending(pm, i));
         BOOST_CHECK(!TestPeerManager::nodeBelongToPeer(pm, i, peerid));
     }
 
     auto alt2_proof = getRandomProofPtr(MIN_VALID_PROOF_SCORE);
     const ProofId &alt2_proofid = alt2_proof->getId();
 
     // Update some nodes from an unknown proof to another unknown proof
     for (int i = 0; i < 5; i++) {
         BOOST_CHECK(!pm.addNode(i, alt2_proofid));
         BOOST_CHECK(TestPeerManager::isNodePending(pm, i));
     }
 
     // Update some nodes from an unknown proof to a known proof
     for (int i = 0; i < 5; i++) {
         BOOST_CHECK(pm.addNode(i, proofid));
         BOOST_CHECK(!TestPeerManager::isNodePending(pm, i));
         BOOST_CHECK(TestPeerManager::nodeBelongToPeer(pm, i, peerid));
     }
 
     // Remove the peer, the nodes should be pending again
     BOOST_CHECK(pm.removePeer(peerid));
     BOOST_CHECK(!pm.getProof(proof->getId()));
     for (int i = 0; i < 10; i++) {
         BOOST_CHECK(TestPeerManager::isNodePending(pm, i));
         BOOST_CHECK(!TestPeerManager::nodeBelongToPeer(pm, i, peerid));
     }
     BOOST_CHECK(pm.verify());
 }
 
 BOOST_AUTO_TEST_CASE(node_binding_reorg) {
     avalanche::PeerManager pm;
 
     ProofBuilder pb(0, 0, CPubKey());
     auto key = CKey::MakeCompressedKey();
     const CScript script = GetScriptForDestination(PKHash(key.GetPubKey()));
     COutPoint utxo(TxId(GetRandHash()), 0);
     Amount amount = 1 * COIN;
     const int height = 1234;
     pb.addUTXO(utxo, amount, height, false, key);
     auto proof = std::make_shared<Proof>(pb.build());
     const ProofId &proofid = proof->getId();
 
     {
         LOCK(cs_main);
         CCoinsViewCache &coins = ::ChainstateActive().CoinsTip();
         coins.AddCoin(utxo, Coin(CTxOut(amount, script), height, false), false);
     }
 
     PeerId peerid = pm.getPeerId(proof);
     BOOST_CHECK_NE(peerid, NO_PEER);
     BOOST_CHECK(pm.verify());
 
     // Add nodes to our peer
     for (int i = 0; i < 10; i++) {
         BOOST_CHECK(pm.addNode(i, proofid));
         BOOST_CHECK(!TestPeerManager::isNodePending(pm, i));
         BOOST_CHECK(TestPeerManager::nodeBelongToPeer(pm, i, peerid));
     }
 
     // Orphan the proof
     {
         LOCK(cs_main);
         CCoinsViewCache &coins = ::ChainstateActive().CoinsTip();
         coins.SpendCoin(utxo);
     }
 
     pm.updatedBlockTip();
     BOOST_CHECK(pm.isOrphan(proofid));
     BOOST_CHECK(!pm.getProof(proofid));
     for (int i = 0; i < 10; i++) {
         BOOST_CHECK(TestPeerManager::isNodePending(pm, i));
         BOOST_CHECK(!TestPeerManager::nodeBelongToPeer(pm, i, peerid));
     }
     BOOST_CHECK(pm.verify());
 
     // Make the proof great again
     {
         LOCK(cs_main);
         CCoinsViewCache &coins = ::ChainstateActive().CoinsTip();
         coins.AddCoin(utxo, Coin(CTxOut(amount, script), height, false), false);
     }
 
     pm.updatedBlockTip();
     BOOST_CHECK(!pm.isOrphan(proofid));
     BOOST_CHECK(pm.getProof(proofid));
     // The peerid has certainly been updated
     peerid = pm.getPeerId(proof);
     BOOST_CHECK_NE(peerid, NO_PEER);
     for (int i = 0; i < 10; i++) {
         BOOST_CHECK(!TestPeerManager::isNodePending(pm, i));
         BOOST_CHECK(TestPeerManager::nodeBelongToPeer(pm, i, peerid));
     }
     BOOST_CHECK(pm.verify());
 }
 
 BOOST_AUTO_TEST_CASE(proof_conflict) {
     auto key = CKey::MakeCompressedKey();
     const CScript script = GetScriptForDestination(PKHash(key.GetPubKey()));
 
     TxId txid1(GetRandHash());
     TxId txid2(GetRandHash());
     BOOST_CHECK(txid1 != txid2);
 
     const Amount v = 5 * COIN;
     const int height = 1234;
 
     {
         LOCK(cs_main);
         CCoinsViewCache &coins = ::ChainstateActive().CoinsTip();
 
         for (int i = 0; i < 10; i++) {
             coins.AddCoin(COutPoint(txid1, i),
                           Coin(CTxOut(v, script), height, false), false);
             coins.AddCoin(COutPoint(txid2, i),
                           Coin(CTxOut(v, script), height, false), false);
         }
     }
 
     avalanche::PeerManager pm;
     const auto getPeerId = [&](const std::vector<COutPoint> &outpoints) {
         ProofBuilder pb(0, 0, CPubKey());
         for (const auto &o : outpoints) {
             pb.addUTXO(o, v, height, false, key);
         }
 
         return pm.getPeerId(std::make_shared<Proof>(pb.build()));
     };
 
     // Add one peer.
     const PeerId peer1 = getPeerId({COutPoint(txid1, 0)});
     BOOST_CHECK(peer1 != NO_PEER);
 
     // Same proof, same peer.
     BOOST_CHECK_EQUAL(getPeerId({COutPoint(txid1, 0)}), peer1);
 
     // Different txid, different proof.
     const PeerId peer2 = getPeerId({COutPoint(txid2, 0)});
     BOOST_CHECK(peer2 != NO_PEER && peer2 != peer1);
 
     // Different index, different proof.
     const PeerId peer3 = getPeerId({COutPoint(txid1, 1)});
     BOOST_CHECK(peer3 != NO_PEER && peer3 != peer1);
 
     // Empty proof, no peer.
     BOOST_CHECK_EQUAL(getPeerId({}), NO_PEER);
 
     // Multiple inputs.
     const PeerId peer4 = getPeerId({COutPoint(txid1, 2), COutPoint(txid2, 2)});
     BOOST_CHECK(peer4 != NO_PEER && peer4 != peer1);
 
     // Duplicated input.
-    BOOST_CHECK_EQUAL(getPeerId({COutPoint(txid1, 3), COutPoint(txid1, 3)}),
-                      NO_PEER);
+    {
+        ProofBuilder pb(0, 0, CPubKey());
+        COutPoint o(txid1, 3);
+        pb.addUTXO(o, v, height, false, key);
+        PeerId peerid = pm.getPeerId(std::make_shared<Proof>(
+            TestProofBuilder::buildDuplicatedStakes(pb)));
+        BOOST_CHECK_EQUAL(peerid, NO_PEER);
+    }
 
     // Multiple inputs, collision on first input.
     BOOST_CHECK_EQUAL(getPeerId({COutPoint(txid1, 0), COutPoint(txid2, 4)}),
                       NO_PEER);
 
     // Mutliple inputs, collision on second input.
     BOOST_CHECK_EQUAL(getPeerId({COutPoint(txid1, 4), COutPoint(txid2, 0)}),
                       NO_PEER);
 
     // Mutliple inputs, collision on both inputs.
     BOOST_CHECK_EQUAL(getPeerId({COutPoint(txid1, 0), COutPoint(txid2, 2)}),
                       NO_PEER);
 }
 
 BOOST_AUTO_TEST_CASE(orphan_proofs) {
     avalanche::PeerManager pm;
 
     auto key = CKey::MakeCompressedKey();
     const CScript script = GetScriptForDestination(PKHash(key.GetPubKey()));
 
     COutPoint outpoint1 = COutPoint(TxId(GetRandHash()), 0);
     COutPoint outpoint2 = COutPoint(TxId(GetRandHash()), 0);
     COutPoint outpoint3 = COutPoint(TxId(GetRandHash()), 0);
 
     const Amount v = 5 * COIN;
     const int height = 1234;
     const int wrongHeight = 12345;
 
     const auto makeProof = [&](const COutPoint &outpoint, const int h) {
         ProofBuilder pb(0, 0, CPubKey());
         pb.addUTXO(outpoint, v, h, false, key);
         return std::make_shared<Proof>(pb.build());
     };
 
     auto proof1 = makeProof(outpoint1, height);
     auto proof2 = makeProof(outpoint2, height);
     auto proof3 = makeProof(outpoint3, wrongHeight);
 
     const Coin coin = Coin(CTxOut(v, script), height, false);
 
     // Add outpoints 1 and 3, not 2
     {
         LOCK(cs_main);
         CCoinsViewCache &coins = ::ChainstateActive().CoinsTip();
         coins.AddCoin(outpoint1, coin, false);
         coins.AddCoin(outpoint3, coin, false);
     }
 
     // Add the proofs
     BOOST_CHECK(pm.getPeerId(proof1) != NO_PEER);
     BOOST_CHECK(pm.getPeerId(proof2) == NO_PEER);
     BOOST_CHECK(pm.getPeerId(proof3) == NO_PEER);
 
     // Good
     BOOST_CHECK(!pm.isOrphan(proof1->getId()));
     // MISSING_UTXO
     BOOST_CHECK(pm.isOrphan(proof2->getId()));
     // HEIGHT_MISMATCH
     BOOST_CHECK(pm.isOrphan(proof3->getId()));
 
     const auto isGoodPeer = [&pm](const std::shared_ptr<Proof> &p) {
         bool ret = false;
         pm.forEachPeer([&](const Peer &peer) {
             if (p->getId() == peer.proof->getId()) {
                 ret = true;
             }
         });
         return ret;
     };
 
     BOOST_CHECK(isGoodPeer(proof1));
     BOOST_CHECK(!isGoodPeer(proof2));
     BOOST_CHECK(!isGoodPeer(proof3));
 
     // Add outpoint2, proof2 is no longer considered orphan
     {
         LOCK(cs_main);
         CCoinsViewCache &coins = ::ChainstateActive().CoinsTip();
         coins.AddCoin(outpoint2, coin, false);
     }
 
     pm.updatedBlockTip();
     BOOST_CHECK(!pm.isOrphan(proof2->getId()));
     BOOST_CHECK(isGoodPeer(proof2));
 
     // The status of proof1 and proof3 are unchanged
     BOOST_CHECK(!pm.isOrphan(proof1->getId()));
     BOOST_CHECK(isGoodPeer(proof1));
     BOOST_CHECK(pm.isOrphan(proof3->getId()));
     BOOST_CHECK(!isGoodPeer(proof3));
 
     // Spend outpoint1, proof1 becomes orphan
     {
         LOCK(cs_main);
         CCoinsViewCache &coins = ::ChainstateActive().CoinsTip();
         coins.SpendCoin(outpoint1);
     }
 
     pm.updatedBlockTip();
     BOOST_CHECK(pm.isOrphan(proof1->getId()));
     BOOST_CHECK(!isGoodPeer(proof1));
 
     // The status of proof2 and proof3 are unchanged
     BOOST_CHECK(!pm.isOrphan(proof2->getId()));
     BOOST_CHECK(isGoodPeer(proof2));
     BOOST_CHECK(pm.isOrphan(proof3->getId()));
     BOOST_CHECK(!isGoodPeer(proof3));
 
     // A reorg could make a previous HEIGHT_MISMATCH become valid
     {
         LOCK(cs_main);
         CCoinsViewCache &coins = ::ChainstateActive().CoinsTip();
         coins.SpendCoin(outpoint3);
         coins.AddCoin(outpoint3, Coin(CTxOut(v, script), wrongHeight, false),
                       false);
     }
 
     pm.updatedBlockTip();
     BOOST_CHECK(!pm.isOrphan(proof3->getId()));
     BOOST_CHECK(isGoodPeer(proof3));
 
     // The status of proof 1 and proof2 are unchanged
     BOOST_CHECK(pm.isOrphan(proof1->getId()));
     BOOST_CHECK(!isGoodPeer(proof1));
     BOOST_CHECK(!pm.isOrphan(proof2->getId()));
     BOOST_CHECK(isGoodPeer(proof2));
 }
 
 BOOST_AUTO_TEST_CASE(dangling_node) {
     avalanche::PeerManager pm;
 
     auto proof = getRandomProofPtr(MIN_VALID_PROOF_SCORE);
     PeerId peerid = pm.getPeerId(proof);
     BOOST_CHECK_NE(peerid, NO_PEER);
 
     const TimePoint theFuture(std::chrono::steady_clock::now() +
                               std::chrono::hours(24));
 
     // Add nodes to this peer and update their request time far in the future
     for (int i = 0; i < 10; i++) {
         BOOST_CHECK(pm.addNode(i, proof->getId()));
         BOOST_CHECK(pm.updateNextRequestTime(i, theFuture));
     }
 
     // Remove the peer
     BOOST_CHECK(pm.removePeer(peerid));
 
     // Check the nodes are still there
     for (int i = 0; i < 10; i++) {
         BOOST_CHECK(pm.forNode(i, [](const Node &n) { return true; }));
     }
 
     // Build a new one
     proof = getRandomProofPtr(MIN_VALID_PROOF_SCORE);
     peerid = pm.getPeerId(proof);
     BOOST_CHECK_NE(peerid, NO_PEER);
 
     // Update the nodes with the new proof
     for (int i = 0; i < 10; i++) {
         BOOST_CHECK(pm.addNode(i, proof->getId()));
         BOOST_CHECK(pm.forNode(
             i, [&](const Node &n) { return n.nextRequestTime == theFuture; }));
     }
 
     // Remove the peer
     BOOST_CHECK(pm.removePeer(peerid));
 
     // Disconnect the nodes
     for (int i = 0; i < 10; i++) {
         BOOST_CHECK(pm.removeNode(i));
     }
 }
 
 BOOST_AUTO_TEST_CASE(proof_accessors) {
     avalanche::PeerManager pm;
 
     constexpr int numProofs = 10;
 
     std::vector<std::shared_ptr<Proof>> proofs;
     proofs.reserve(numProofs);
     for (int i = 0; i < numProofs; i++) {
         proofs.push_back(getRandomProofPtr(MIN_VALID_PROOF_SCORE));
     }
 
     for (int i = 0; i < numProofs; i++) {
         BOOST_CHECK(pm.registerProof(proofs[i]));
         // Fail to add an existing proof
         BOOST_CHECK(!pm.registerProof(proofs[i]));
 
         for (int added = 0; added <= i; added++) {
             auto proof = pm.getProof(proofs[added]->getId());
             BOOST_CHECK(proof != nullptr);
 
             const ProofId &proofid = proof->getId();
             BOOST_CHECK_EQUAL(proofid, proofs[added]->getId());
         }
     }
 
     // No stake, copied from proof_tests.cpp
     const std::string badProofHex(
         "96527eae083f1f24625f049d9e54bb9a2102a93d98bf42ab90cfc0bf9e7c634ed76a7"
         "3e95b02cacfd357b64e4fb6c92e92dd00");
     bilingual_str error;
     Proof badProof;
     BOOST_CHECK(Proof::FromHex(badProof, badProofHex, error));
     BOOST_CHECK(
         !pm.registerProof(std::make_shared<Proof>(std::move(badProof))));
 }
 
 BOOST_AUTO_TEST_SUITE_END()
diff --git a/src/avalanche/test/proof_tests.cpp b/src/avalanche/test/proof_tests.cpp
index cf091200c..4604dab3c 100644
--- a/src/avalanche/test/proof_tests.cpp
+++ b/src/avalanche/test/proof_tests.cpp
@@ -1,495 +1,494 @@
 // Copyright (c) 2020 The Bitcoin developers
 // Distributed under the MIT software license, see the accompanying
 // file COPYING or http://www.opensource.org/licenses/mit-license.php.
 
 #include <avalanche/proof.h>
 
 #include <avalanche/proofbuilder.h>
 #include <avalanche/test/util.h>
 #include <avalanche/validation.h>
 #include <coins.h>
 #include <script/standard.h>
 #include <streams.h>
 #include <util/strencodings.h>
 
 #include <test/util/setup_common.h>
 
 #include <boost/test/unit_test.hpp>
 
 using namespace avalanche;
 
 BOOST_FIXTURE_TEST_SUITE(proof_tests, TestingSetup)
 
 BOOST_AUTO_TEST_CASE(proof_random) {
     for (int i = 0; i < 1000; i++) {
         const uint32_t score = InsecureRand32();
         const Proof p = buildRandomProof(score);
         BOOST_CHECK_EQUAL(p.getScore(), score);
 
         ProofValidationResult expected_state =
             hasDustStake(p) ? ProofValidationResult::DUST_THRESOLD
                             : ProofValidationResult::NONE;
 
         ProofValidationState state;
         BOOST_CHECK_EQUAL(p.verify(state),
                           state.GetResult() == ProofValidationResult::NONE);
         BOOST_CHECK(state.GetResult() == expected_state);
     }
 }
 
 BOOST_AUTO_TEST_CASE(proofbuilder) {
     // Master key.
     auto key = CKey::MakeCompressedKey();
     const CPubKey master = key.GetPubKey();
 
     const uint64_t sequence = InsecureRandBits(64);
     const int64_t expiration = InsecureRandBits(64);
 
     ProofBuilder pb(sequence, expiration, master);
 
     for (int i = 0; i < 3; i++) {
         key.MakeNewKey(true);
         pb.addUTXO(COutPoint(TxId(GetRandHash()), InsecureRand32()),
                    int64_t(InsecureRand32()) * COIN / 100, InsecureRand32(),
                    InsecureRandBool(), key);
     }
 
     Proof p = pb.build();
 
     ProofValidationState state;
     BOOST_CHECK(p.verify(state));
 
     BOOST_CHECK_EQUAL(p.getSequence(), sequence);
     BOOST_CHECK_EQUAL(p.getExpirationTime(), expiration);
     BOOST_CHECK(p.getMaster() == master);
 
     BOOST_CHECK(state.GetResult() == ProofValidationResult::NONE);
 }
 
 struct TestVector {
     std::string name;
     std::string hex;
     ProofId proofid;
     uint32_t score;
     ProofValidationResult result;
 };
 
 BOOST_AUTO_TEST_CASE(deserialization) {
     std::vector<TestVector> testcases{
         {"No utxo staked",
          "96527eae083f1f24625f049d9e54bb9a2102a93d98bf42ab90cfc0bf9e7c634ed76a7"
          "3e95b02cacfd357b64e4fb6c92e92dd00",
          ProofId::fromHex("19f6631738a5a0196bf6152dcdb40de4675954567b444631cdec"
                           "52d4c39b5316"),
          0, ProofValidationResult::NO_STAKE},
         {"1 utxo staked",
          "a6d66db9fe9378fdd37a0ad2c01c2acd2103648144bb6a0c1d09b0f04d0df6d55f914"
          "fd81efc65f23a718b68b7c9e42bd5430145a4d07798547464daa53acefb7c97c0c415"
          "ed8e81e549ff56a0ef6f847fcc9ca855b36200fe38dce5060000e707d7274104fb662"
          "6e21dbd1cc9feeecdefc9213fdce2b51ac4bb44e1f8dc6f14c2052f5dd7bfaeb2267a"
          "97ca2bec6e0dd4acf50a66204bde1ebb5d6c551684cff2f939920f7fbb2efd860d6d5"
          "926bf425eb47b78bf6979cdcd67eb705e2c9a4d45a0930ba25463178a3fb99cb28c8b"
          "77d8fcf68c54ebfadf08b9a446c251a0088301c50d53",
          ProofId::fromHex("82754c0d4170521b19360c6862483ad435b7b95f078aedf781d6"
                           "9a6c5b89a916"),
          7584312, ProofValidationResult::INVALID_SIGNATURE},
         {"2 utxo staked",
          "872379ab64f55b4166ca0e79639999ec4104a66861de557a54eefc0375264cc17c3a3"
          "50ccabca6fd9c91883e899ab55bb140517aa56c5b4041908e7027a786b99f66488a04"
          "135ce5fe189a99a7bc541ddfe602fabf3ad5b875840e7813a66d5ea8a1288a49b6222"
          "b59fcbe6249f94e5927f9f4b884b0b040a534b3ba040000d045d5d021036830e697b0"
          "ee89866da798a8945bd85b352545ec1bcace7e04909ea54c134f16d5fe4e972b7acd2"
          "9ebfc2b7b11c26974b84e5f21a45bbe8372472f59e5dfdea7e9e5857c6aebe5dbc5e6"
          "46dfbf4e7cee380afaddb15d06153bf1755b9ef00a616d4c8c3c3a662b5eddc192656"
          "4a488e3e68e334291078001480f7fa5144ef3a606a41e85c0218dd377090000e41099"
          "912102ebfcea8e1864c1273c41e0d7c1e9097be5c491bbbf5fe31161d8e5589b9d6b5"
          "b12f3b963c7fc7614d56d83af907e5cb18ac2f4c3e70a8c4253995f6bc002ec5e3504"
          "91c965cba4dbc11c210979217f1ac3ece7a748f5b2fcf5cced40a5d4c40e",
          ProofId::fromHex("ba5aba9be72c9c2c52f857b81245e1ec85c879bbc8e111008673"
                           "d78c26610b05"),
          15610172, ProofValidationResult::INVALID_SIGNATURE},
         {"3 utxo staked",
          "525e2aa04af0e2457c66ac9e7f66257f210252db8e3ceea6fca44a7696e82f7b77e5a"
          "4025e60ac60271b174e91ffbb6ce01f039ce8d3b77938e49ce3bc9824e90b72c65542"
          "2fb502f137e03a4499e5223d10096fe541eb80316ce3c80800000285f59341044fd7e"
          "95de7c7bb30e7f60434a3e1a414a9e5d9c383c7b27396b1b84355a32e2996ecb98dc2"
          "0143089932fa1b905a60fc3cfefeea193c91d1405f7c03de494fa4de065c067d64606"
          "0e9270281c316d5c4c01d7e43d009151a72bf647794ce1727cbefaeb19719f916cd4d"
          "d176c376a4da72431b61736d4a3e01c25ba057eac0af8f2988b78d1b75e02281fac56"
          "2357a06353bf7f214c883e65add05b3a616300cb99cc963c0f4ded8c00e0000b03aab"
          "f82103172b4f1890594508ab1e0cc5e9728b8a249660da4df724762a8fd888e8ece1b"
          "d6fe923ed17ad0fd77a90d31e3877de1a8cdb4e95bcf2cdd6fb9768f86789f253b432"
          "f3b5058b2d1892e90882529055fdedf8ae5d3280b2404a65321cf7f7229202db300ff"
          "2897e33259a81dfc4bf296c3a156dc8dbfa074c602dd2250cc531b346fc28bb80ddf2"
          "9ddc020000a713a5bb21035615635d449988a4eea03fd317e44481bde2e34a2489f3f"
          "b24f0b0ea1cbfc4030bec095a8d3e9c2a233778535dc1fcc07755149b23ea8c17931a"
          "37e9377eaa2f45bafb8d0bb9ba1700aab88fd6a53ea3e83d95ad2d84e7abe828f5570"
          "91b185e",
          ProofId::fromHex("9ea64e9760f2c7832f1c9840923947915361acb22dcc0bae4404"
                           "94be0d51842d"),
          29026903, ProofValidationResult::INVALID_SIGNATURE},
         {"4 utxo staked",
          "eef33172651f752ac255c85a4e1374992102c12b37ff6139157865fc4c3a9d7ad999b"
          "686ade45d453545d04e76f6e14793b404295de5ebf9fbbbb65fc1d9a71587c5284cff"
          "b2e834addefe090b8200435668c8f02c0b0100689a117e0e000007d801582102a682d"
          "9d12d53b0eb37a3af2838510f079041905a75f82b6a3fb5558728d781fbf868d1d968"
          "27b273f5a79f84ebe23add967a98f472fb80323439d0a65d546fc3745806f6d7f3381"
          "24a7a2573864e97a26246644a7d7b05d97943dfcdb4b694df631e6dc5f87e28c1fe3e"
          "5ba021f38c471638769041db81ffcf8c9887d078419f97fe2a2c408fee822c0600001"
          "689b9cd2102e38d0adddcd7c88e3c87b8babcae10647e2862fb719839fc8890e42aeb"
          "929b85e1a3f14e2cdc65e2b1396f2dae41b047958cdc7e4d2f6fa051065829e26797c"
          "5b882e45bb9fea32c0b0e0ad90f8ac1e5d8d0b16a9b74d77614b7fd99e56b6091aca3"
          "67f8f7a68d1b654e51dd00733bd191dc9bea2ba750e063b05d962aaf9c4d2088ce4f0"
          "03e73e253040000a5eebe222103a20dd85b66b44b22fdd17a93762194c9bedb442c7f"
          "fd7f08a9f82c42a8c1d9a0443f700cb8a40c8cf7f840b5137b6d019efed961771d095"
          "88b0eb3c5e1672bb95b06ca7e2068e564001aa75b8c37bb6601117c286b6b0c9728d1"
          "e928ab02e3b67e9422b484ef2624ce5de974b5bd616874ec39d03d32ed0bf114759b7"
          "0bf5dcef51534b100515301140f0000950121754104d66dba1569164a134111961133"
          "4bad5e2d398823f1454ceecb9c4266fd3ba4b969ac4d4f6c4b3975d19c2f7dcbbca09"
          "6af5395780a2d3c42505146c095bc861fab15238fb8aa1fb82c7ad28b0ee5d1335348"
          "76dc7887490c7c6e61103b2cd221f1991826a73fecf08e0b5a0a7d357a5431eee032d"
          "14a348c80ca1833d68b3d7b",
          ProofId::fromHex("ae60f62b336c6a948f95af123bc25574b0c5f423d1cab8f795d3"
                           "bf8f895457f3"),
          44059793, ProofValidationResult::INVALID_SIGNATURE},
         {"Properly signed 1 UTXO proof",
          "d97587e6c882615796011ec8f9a7b1c6410469ab5a892ffa4bb104a3d5760dd893a55"
          "02512eea4ba32a6d6672767be4959c0f70489b803a47a3abf83f30e8d9da978de4027"
          "c70ce7e0d3b0ad62eb08edd8f90169a79ff23e1d58c64afad42ad81cffe53967e16be"
          "b692fc5776bb442c79c5d91de00cf21804712806594010038e168a32102449fb5237e"
          "fe8f647d32e8b64f06c22d1d40368eaca2a71ffc6a13ecc8bce6800a7b4811c6412ad"
          "f94b0d6bb5227aeec27f49b2948b6e3da564d12d96ff00779f113d52c82093e101323"
          "4440ad829030c685ca03d4fd9ce95b298e79c5eee6e2",
          ProofId::fromHex("cbd77dad2ebc525c591ab44a0f6a25803c1d934c3e5caa61f9f4"
                           "c63c9f29a4e6"),
          444638638, ProofValidationResult::NONE},
         {"Duplicated UTXO",
          "60f8332a3ff3430a4f3c9010160cc63e21023beefdde700a6bc02036335b4df141c8b"
          "c67bb05a971f5ac2745fd683797dde302d1e26c2287948bc6ab2b55945c591b8ba3ff"
          "a237f5d9164d30a4f10145a61f788e639b1480731e2aead30500bf8462872102449fb"
          "5237efe8f647d32e8b64f06c22d1d40368eaca2a71ffc6a13ecc8bce680f43f437a2d"
          "8910aa81ff6c5619dd7b27a1e4b794841e3ab60a3878cf00cff8c0135dc85e451e179"
          "34b252b51b44db5a8761d215565cc9533cdecfda0870ef079d1e26c2287948bc6ab2b"
          "55945c591b8ba3ffa237f5d9164d30a4f10145a61f788e639b1480731e2aead30500b"
          "f8462872102449fb5237efe8f647d32e8b64f06c22d1d40368eaca2a71ffc6a13ecc8"
          "bce680f43f437a2d8910aa81ff6c5619dd7b27a1e4b794841e3ab60a3878cf00cff8c"
          "0135dc85e451e17934b252b51b44db5a8761d215565cc9533cdecfda0870ef079",
          ProofId::fromHex("a7cd6e76b5766cf4fc2251da4a01668682a1786d4b76539e04d7"
                           "f79cebeb5983"),
          3280755132, ProofValidationResult::DUPLICATE_STAKE},
         {"Properly signed 3 UTXO proof",
          "c964aa6fde575e4ce8404581c7be874e21038439233261789dd340bdc1450172d9c67"
          "1b72ee8c0b2736ed2a3a250760897fd03e4ed76e1f19b2c2a0fcc069b4ace4a078cb5"
          "cc31e9e19b266d0af41ea8bb0c30c8b47c95a856d9aa000000007dfdd89a21030f588"
          "3ac0b61082277ad94d9f5f979baffc49d516167aeda0eb7de30db319a411f97bc976e"
          "0490468f2f6d552c8cf87e8def1492b8ac81df0b4448a3c212e9000f9e753b97c93e0"
          "2fbe8976c95488b54a24f7df00d3cfed308701e6d690c394cac098c86414715db364a"
          "4e32216084c561acdd79e0860b1fdf7497b159cb13230451200296c902ee000000009"
          "f2bc7392102a397e8e1f737cae7d8c41ec68445261e9201ed36bc694d753095f716b3"
          "97319d5c5ef9a7712ec77b6826b29bf53691bbcb6873a326f313efb8cdb8911715bc6"
          "7d61a3b804f9ac9162374c6df42dc918b0ba3f05d0578cd9f96d5078c903b89f30b1e"
          "5f35704cb63360aa3d5f444ee35eea4c154c1af6d4e7595b409ada4b42377764698a9"
          "15c2ac4000000000f28db3221039f1ae9bbeeafa63abdc362f0a2c00e6c0582615b79"
          "61745180c47a0b7800abc1e97c016b9e99625394b738643e8ef0d3d4936165caff79c"
          "1070d36ca432ba04dbbb54474a42f9e72587d05ba6353ce1be41a0e80e2d2257bc444"
          "99fa26f5c1d7",
          ProofId::fromHex("317289c8d2f4fb7b4fea5195e4dbc9804018c6aab71606b50e27"
                           "ddd8e2d985db"),
          10150, ProofValidationResult::NONE},
         {"Changing sequence affect ProofId",
          "d87587e6c882615796011ec8f9a7b1c6410469ab5a892ffa4bb104a3d5760dd893a55"
          "02512eea4ba32a6d6672767be4959c0f70489b803a47a3abf83f30e8d9da978de4027"
          "c70ce7e0d3b0ad62eb08edd8f90169a79ff23e1d58c64afad42ad81cffe53967e16be"
          "b692fc5776bb442c79c5d91de00cf21804712806594010038e168a32102449fb5237e"
          "fe8f647d32e8b64f06c22d1d40368eaca2a71ffc6a13ecc8bce6800a7b4811c6412ad"
          "f94b0d6bb5227aeec27f49b2948b6e3da564d12d96ff00779f113d52c82093e101323"
          "4440ad829030c685ca03d4fd9ce95b298e79c5eee6e2",
          ProofId::fromHex("333c462a0161e9146da55d77733a2d4ccd022217a70beb004742"
                           "5069f1d32ed5"),
          444638638, ProofValidationResult::INVALID_SIGNATURE},
         {"Changing expiration affect ProofId",
          "d97587e6c882615797011ec8f9a7b1c6410469ab5a892ffa4bb104a3d5760dd893a55"
          "02512eea4ba32a6d6672767be4959c0f70489b803a47a3abf83f30e8d9da978de4027"
          "c70ce7e0d3b0ad62eb08edd8f90169a79ff23e1d58c64afad42ad81cffe53967e16be"
          "b692fc5776bb442c79c5d91de00cf21804712806594010038e168a32102449fb5237e"
          "fe8f647d32e8b64f06c22d1d40368eaca2a71ffc6a13ecc8bce6800a7b4811c6412ad"
          "f94b0d6bb5227aeec27f49b2948b6e3da564d12d96ff00779f113d52c82093e101323"
          "4440ad829030c685ca03d4fd9ce95b298e79c5eee6e2",
          ProofId::fromHex("6b7d6b32a88e68e830454bb0189ac14dc938917bdc64f22ef11d"
                           "d41535ede85a"),
          444638638, ProofValidationResult::INVALID_SIGNATURE},
         {"Changing the master key affect ProofId",
          "d97587e6c882615796011ec8f9a7b1c6410469aa5a892ffa4bb104a3d5760dd893a55"
          "02512eea4ba32a6d6672767be4959c0f70489b803a47a3abf83f30e8d9da978de4027"
          "c70ce7e0d3b0ad62eb08edd8f90169a79ff23e1d58c64afad42ad81cffe53967e16be"
          "b692fc5776bb442c79c5d91de00cf21804712806594010038e168a32102449fb5237e"
          "fe8f647d32e8b64f06c22d1d40368eaca2a71ffc6a13ecc8bce6800a7b4811c6412ad"
          "f94b0d6bb5227aeec27f49b2948b6e3da564d12d96ff00779f113d52c82093e101323"
          "4440ad829030c685ca03d4fd9ce95b298e79c5eee6e2",
          ProofId::fromHex("d4e2673f9df2e5c506892f3794b986910c77aa9b0c292cdcfea8"
                           "3dd804008b00"),
          444638638, ProofValidationResult::INVALID_SIGNATURE},
         {"Changing the TxId affect the ProofId",
          "d97587e6c882615796011ec8f9a7b1c6410469ab5a892ffa4bb104a3d5760dd893a55"
          "02512eea4ba32a6d6672767be4959c0f70489b803a47a3abf83f30e8d9da978de4027"
          "c70ce7e0d3b0ad62eb08edd8f90179a79ff23e1d58c64afad42ad81cffe53967e16be"
          "b692fc5776bb442c79c5d91de00cf21804712806594010038e168a32102449fb5237e"
          "fe8f647d32e8b64f06c22d1d40368eaca2a71ffc6a13ecc8bce6800a7b4811c6412ad"
          "f94b0d6bb5227aeec27f49b2948b6e3da564d12d96ff00779f113d52c82093e101323"
          "4440ad829030c685ca03d4fd9ce95b298e79c5eee6e2",
          ProofId::fromHex("fefa0e3d8f76358431caba523ac71faaf57921bb6f1049f74a3e"
                           "8bebd512c20b"),
          444638638, ProofValidationResult::INVALID_SIGNATURE},
         {"Changing the outpoint index change the ProofId",
          "d97587e6c882615796011ec8f9a7b1c6410469ab5a892ffa4bb104a3d5760dd893a55"
          "02512eea4ba32a6d6672767be4959c0f70489b803a47a3abf83f30e8d9da978de4027"
          "c70ce7e0d3b0ad62eb08edd8f90169a79ff23e1d58c64afad42ad81cffe53967e16be"
          "b692fc5776bb442c79c5d91df00cf21804712806594010038e168a32102449fb5237e"
          "fe8f647d32e8b64f06c22d1d40368eaca2a71ffc6a13ecc8bce6800a7b4811c6412ad"
          "f94b0d6bb5227aeec27f49b2948b6e3da564d12d96ff00779f113d52c82093e101323"
          "4440ad829030c685ca03d4fd9ce95b298e79c5eee6e2",
          ProofId::fromHex("a9f6b78b97a01d21d47b834bb8bf5d9397f50bfac115ec3da05b"
                           "695189aef040"),
          444638638, ProofValidationResult::INVALID_SIGNATURE},
         {"Changing the amount changes the ProofId",
          "d97587e6c882615796011ec8f9a7b1c6410469ab5a892ffa4bb104a3d5760dd893a55"
          "02512eea4ba32a6d6672767be4959c0f70489b803a47a3abf83f30e8d9da978de4027"
          "c70ce7e0d3b0ad62eb08edd8f90169a79ff23e1d58c64afad42ad81cffe53967e16be"
          "b692fc5776bb442c79c5d91de00cf21814712806594010038e168a32102449fb5237e"
          "fe8f647d32e8b64f06c22d1d40368eaca2a71ffc6a13ecc8bce6800a7b4811c6412ad"
          "f94b0d6bb5227aeec27f49b2948b6e3da564d12d96ff00779f113d52c82093e101323"
          "4440ad829030c685ca03d4fd9ce95b298e79c5eee6e2",
          ProofId::fromHex("89796be200e6eeeefdb894e47f16653afc572310d5f94c859cac"
                           "628ffc0d9781"),
          444638638, ProofValidationResult::INVALID_SIGNATURE},
         {"Changing the height changes the ProofId",
          "d97587e6c882615796011ec8f9a7b1c6410469ab5a892ffa4bb104a3d5760dd893a55"
          "02512eea4ba32a6d6672767be4959c0f70489b803a47a3abf83f30e8d9da978de4027"
          "c70ce7e0d3b0ad62eb08edd8f90169a79ff23e1d58c64afad42ad81cffe53967e16be"
          "b692fc5776bb442c79c5d91de00cf21804712806594010028e168a32102449fb5237e"
          "fe8f647d32e8b64f06c22d1d40368eaca2a71ffc6a13ecc8bce6800a7b4811c6412ad"
          "f94b0d6bb5227aeec27f49b2948b6e3da564d12d96ff00779f113d52c82093e101323"
          "4440ad829030c685ca03d4fd9ce95b298e79c5eee6e2",
          ProofId::fromHex("77db71b3099331de1e09262d03ee4a5f2d2c21f5abc48f68e28d"
                           "456cecc822ce"),
          444638638, ProofValidationResult::INVALID_SIGNATURE},
         {"Changing the pubkey changes the ProofId",
          "d97587e6c882615796011ec8f9a7b1c6410469ab5a892ffa4bb104a3d5760dd893a55"
          "02512eea4ba32a6d6672767be4959c0f70489b803a47a3abf83f30e8d9da978de4027"
          "c70ce7e0d3b0ad62eb08edd8f90169a79ff23e1d58c64afad42ad81cffe53967e16be"
          "b692fc5776bb442c79c5d91de00cf21804712806594010038e168a32102459fb5237e"
          "fe8f647d32e8b64f06c22d1d40368eaca2a71ffc6a13ecc8bce6800a7b4811c6412ad"
          "f94b0d6bb5227aeec27f49b2948b6e3da564d12d96ff00779f113d52c82093e101323"
          "4440ad829030c685ca03d4fd9ce95b298e79c5eee6e2",
          ProofId::fromHex("3663e72aae7fe4dacde5aa6d5e6f2a3041171d9e7756a47662e1"
                           "e0a11e82621c"),
          444638638, ProofValidationResult::INVALID_SIGNATURE},
         {"Changing the signature does NOT change the ProofId",
          "d97587e6c882615796011ec8f9a7b1c6410469ab5a892ffa4bb104a3d5760dd893a55"
          "02512eea4ba32a6d6672767be4959c0f70489b803a47a3abf83f30e8d9da978de4027"
          "c70ce7e0d3b0ad62eb08edd8f90169a79ff23e1d58c64afad42ad81cffe53967e16be"
          "b692fc5776bb442c79c5d91de00cf21804712806594010038e168a32102449fb5237e"
          "fe8f647d32e8b64f06c22d1d40368eaca2a71ffc6a13ecc8bce6800a7b4811c6412ad"
          "f94b0d6bb5227aeec27f49b2948b6e3da564d12d96ff00779f113d52c82093e101323"
          "4440ad829030c685ca03d4fd9ce95b298e79c5eee6e3",
          ProofId::fromHex("cbd77dad2ebc525c591ab44a0f6a25803c1d934c3e5caa61f9f4"
                           "c63c9f29a4e6"),
          444638638, ProofValidationResult::INVALID_SIGNATURE},
         {"1 utxo staked but zero coins",
          "a6d6852ffa70b172d37a0ad2c01c2acd21023beefdde700a6bc02036335b4df141c8b"
          "c67bb05a971f5ac2745fd683797dde30145a4d07798547464daa53acefb7c97c0c415"
          "ed8e81e549ff56a0ef6f847fcc9ca855b3620000000000000000e707d7272102449fb"
          "5237efe8f647d32e8b64f06c22d1d40368eaca2a71ffc6a13ecc8bce68065cd42e0e6"
          "9d511ad24ecb3c3af07176bcf890caa7cfc64039dc65e51014dd99d11bd00ffbfbcc1"
          "9619ca502bfd4dd6dbc0967692ff6d2211b0bd9b9f05e1298",
          ProofId::fromHex("38f7c9696f9c2c07db3f23024d550a6b0b7f851013074280dbe3"
                           "49f42a2a5a00"),
          0, ProofValidationResult::DUST_THRESOLD},
     };
 
     for (auto &c : testcases) {
         CDataStream stream(ParseHex(c.hex), SER_NETWORK, 0);
         Proof p;
         stream >> p;
         BOOST_CHECK_EQUAL(p.getId(), c.proofid);
         BOOST_CHECK_EQUAL(p.getScore(), c.score);
 
         ProofValidationState state;
         BOOST_CHECK_EQUAL(p.verify(state),
                           c.result == ProofValidationResult::NONE);
         BOOST_CHECK(state.GetResult() == c.result);
         BOOST_TEST_MESSAGE(c.proofid);
     }
 }
 
 BOOST_AUTO_TEST_CASE(verify) {
     CCoinsView coinsDummy;
     CCoinsViewCache coins(&coinsDummy);
 
     auto key = CKey::MakeCompressedKey();
     const CPubKey pubkey = key.GetPubKey();
 
     const Amount value = 12345 * COIN;
     const uint32_t height = 10;
 
     COutPoint pkh_outpoint(TxId(InsecureRand256()), InsecureRand32());
     CTxOut pkh_output(value, GetScriptForRawPubKey(pubkey));
     coins.AddCoin(pkh_outpoint, Coin(pkh_output, height, false), false);
 
     COutPoint nonstd_outpoint(TxId(InsecureRand256()), InsecureRand32());
     CTxOut nonstd_output(value, CScript() << OP_TRUE);
     coins.AddCoin(nonstd_outpoint, Coin(nonstd_output, height, false), false);
 
     COutPoint p2sh_outpoint(TxId(InsecureRand256()), InsecureRand32());
     CTxOut p2sh_output(value,
                        GetScriptForDestination(ScriptHash(InsecureRand160())));
     coins.AddCoin(p2sh_outpoint, Coin(p2sh_output, height, false), false);
 
     const auto runCheck = [&](const ProofValidationResult result,
                               const COutPoint &o, const Amount v,
                               const uint32_t h, const bool is_coinbase,
                               const CKey &k) {
         // Generate a proof that match the UTXO.
         ProofBuilder pb(0, 0, pubkey);
         pb.addUTXO(o, v, h, is_coinbase, k);
         Proof p = pb.build();
 
         ProofValidationState state;
         BOOST_CHECK(p.verify(state));
         BOOST_CHECK(p.verify(state, coins) ==
                     (result == ProofValidationResult::NONE));
         BOOST_CHECK(state.GetResult() == result);
     };
 
     // Valid proof
     runCheck(ProofValidationResult::NONE, pkh_outpoint, value, height, false,
              key);
 
     // Coinbase mismatch
     runCheck(ProofValidationResult::COINBASE_MISMATCH, pkh_outpoint, value,
              height, true, key);
 
     // Height mismatch
     runCheck(ProofValidationResult::HEIGHT_MISMATCH, pkh_outpoint, value,
              height + 1, false, key);
 
     // Amount mismatch
     runCheck(ProofValidationResult::AMOUNT_MISMATCH, pkh_outpoint,
              value + 1 * SATOSHI, height, false, key);
 
     // Invalid outpoints
     runCheck(ProofValidationResult::MISSING_UTXO,
              COutPoint(pkh_outpoint.GetTxId(), pkh_outpoint.GetN() + 1), value,
              height, false, key);
     runCheck(ProofValidationResult::MISSING_UTXO,
              COutPoint(TxId(InsecureRand256()), pkh_outpoint.GetN()), value,
              height, false, key);
 
     // Non standard script
     runCheck(ProofValidationResult::NON_STANDARD_DESTINATION, nonstd_outpoint,
              value, height, false, key);
 
     // Non PKHhash destination
     runCheck(ProofValidationResult::DESTINATION_NOT_SUPPORTED, p2sh_outpoint,
              value, height, false, key);
 
     // Mismatching key
     {
         runCheck(ProofValidationResult::DESTINATION_MISMATCH, pkh_outpoint,
                  value, height, false, CKey::MakeCompressedKey());
     }
 
     // No stake
     {
         Proof p = ProofBuilder(0, 0, pubkey).build();
 
         ProofValidationState state;
         BOOST_CHECK(!p.verify(state, coins));
         BOOST_CHECK(state.GetResult() == ProofValidationResult::NO_STAKE);
     }
 
     // Dust thresold
     {
         ProofBuilder pb(0, 0, pubkey);
         pb.addUTXO(pkh_outpoint, Amount::zero(), height, false, key);
         Proof p = pb.build();
 
         ProofValidationState state;
         BOOST_CHECK(!p.verify(state, coins));
         BOOST_CHECK(state.GetResult() == ProofValidationResult::DUST_THRESOLD);
     }
 
     {
         ProofBuilder pb(0, 0, pubkey);
         pb.addUTXO(pkh_outpoint, PROOF_DUST_THRESHOLD - 1 * SATOSHI, height,
                    false, key);
         Proof p = pb.build();
 
         ProofValidationState state;
         BOOST_CHECK(!p.verify(state, coins));
         BOOST_CHECK(state.GetResult() == ProofValidationResult::DUST_THRESOLD);
     }
 
     // Duplicated input
     {
         ProofBuilder pb(0, 0, pubkey);
         pb.addUTXO(pkh_outpoint, value, height, false, key);
-        pb.addUTXO(pkh_outpoint, value, height, false, key);
-        Proof p = pb.build();
+        Proof p = TestProofBuilder::buildDuplicatedStakes(pb);
 
         ProofValidationState state;
         BOOST_CHECK(!p.verify(state, coins));
         BOOST_CHECK(state.GetResult() ==
                     ProofValidationResult::DUPLICATE_STAKE);
     }
 
     // Wrong stake ordering
     {
         COutPoint other_pkh_outpoint(TxId(InsecureRand256()), InsecureRand32());
         CTxOut other_pkh_output(value, GetScriptForRawPubKey(pubkey));
         coins.AddCoin(other_pkh_outpoint, Coin(other_pkh_output, height, false),
                       false);
 
         ProofBuilder pb(0, 0, pubkey);
         pb.addUTXO(pkh_outpoint, value, height, false, key);
         pb.addUTXO(other_pkh_outpoint, value, height, false, key);
         Proof p = TestProofBuilder::buildWithReversedOrderStakes(pb);
 
         ProofValidationState state;
         BOOST_CHECK(!p.verify(state, coins));
         BOOST_CHECK(state.GetResult() ==
                     ProofValidationResult::WRONG_STAKE_ORDERING);
     }
 }
 
 BOOST_AUTO_TEST_CASE(deterministic_proofid) {
     CCoinsView coinsDummy;
     CCoinsViewCache coins(&coinsDummy);
 
     auto key = CKey::MakeCompressedKey();
     const CPubKey pubkey = key.GetPubKey();
 
     const Amount value = 12345 * COIN;
     const uint32_t height = 10;
 
     std::vector<COutPoint> outpoints(10);
     for (size_t i = 0; i < 10; i++) {
         outpoints[i] = COutPoint(TxId(InsecureRand256()), InsecureRand32());
     }
 
     auto computeProofId = [&]() {
         ProofBuilder pb(0, 0, pubkey);
         for (const COutPoint &outpoint : outpoints) {
             pb.addUTXO(outpoint, value, height, false, key);
         }
         Proof p = pb.build();
 
         return p.getId();
     };
 
     const ProofId proofid = computeProofId();
     Shuffle(outpoints.begin(), outpoints.end(), FastRandomContext());
     BOOST_CHECK_EQUAL(proofid, computeProofId());
 }
 
 BOOST_AUTO_TEST_SUITE_END()
diff --git a/src/avalanche/test/util.cpp b/src/avalanche/test/util.cpp
index 6dbfe8697..7f99e8ed3 100644
--- a/src/avalanche/test/util.cpp
+++ b/src/avalanche/test/util.cpp
@@ -1,87 +1,117 @@
 // Copyright (c) 2020 The Bitcoin developers
 // Distributed under the MIT software license, see the accompanying
 // file COPYING or http://www.opensource.org/licenses/mit-license.php.
 
 #include <amount.h>
 #include <avalanche/proofbuilder.h>
 #include <avalanche/test/util.h>
 #include <key.h>
 #include <primitives/transaction.h>
 #include <random.h>
 #include <script/standard.h>
 #include <validation.h>
 
 #include <limits>
 
 namespace avalanche {
 
 Proof buildRandomProof(uint32_t score, const CPubKey &master) {
     auto key = CKey::MakeCompressedKey();
 
     const COutPoint o(TxId(GetRandHash()), 0);
     const Amount v = (int64_t(score) * COIN) / 100;
     const int height = 1234;
     const bool is_coinbase = false;
 
     {
         CScript script = GetScriptForDestination(PKHash(key.GetPubKey()));
 
         LOCK(cs_main);
         CCoinsViewCache &coins = ::ChainstateActive().CoinsTip();
         coins.AddCoin(o, Coin(CTxOut(v, script), height, is_coinbase), false);
     }
 
     ProofBuilder pb(0, std::numeric_limits<uint32_t>::max(), master);
     pb.addUTXO(o, v, height, is_coinbase, std::move(key));
     return pb.build();
 }
 
 bool hasDustStake(const Proof &proof) {
     for (const SignedStake &s : proof.getStakes()) {
         if (s.getStake().getAmount() < PROOF_DUST_THRESHOLD) {
             return true;
         }
     }
     return false;
 }
 
 ProofId TestProofBuilder::getReverseOrderProofId(ProofBuilder &pb) {
     CHashWriter ss(SER_GETHASH, 0);
     ss << pb.sequence;
     ss << pb.expirationTime;
 
-    // Reverse the sorting order
-    std::sort(pb.stakes.begin(), pb.stakes.end(),
-              [](const ProofBuilder::StakeSigner &lhs,
-                 const ProofBuilder::StakeSigner &rhs) {
-                  return lhs.stake.getId() > rhs.stake.getId();
-              });
-
     WriteCompactSize(ss, pb.stakes.size());
-    for (const auto &s : pb.stakes) {
-        ss << s.stake;
+    for (auto it = pb.stakes.rbegin(); it != pb.stakes.rend(); it++) {
+        ss << it->stake;
     }
 
     CHashWriter ss2(SER_GETHASH, 0);
     ss2 << ss.GetHash();
     ss2 << pb.master;
 
     return ProofId(ss2.GetHash());
 }
 
 Proof TestProofBuilder::buildWithReversedOrderStakes(ProofBuilder &pb) {
     const ProofId proofid = TestProofBuilder::getReverseOrderProofId(pb);
 
     std::vector<SignedStake> signedStakes;
     signedStakes.reserve(pb.stakes.size());
 
+    while (!pb.stakes.empty()) {
+        // We need a forward iterator, so pb.stakes.rbegin() is not an
+        // option.
+        auto handle = pb.stakes.extract(std::prev(pb.stakes.end()));
+        signedStakes.push_back(handle.value().sign(proofid));
+    }
+
+    return Proof(pb.sequence, pb.expirationTime, std::move(pb.master),
+                 std::move(signedStakes));
+}
+
+ProofId TestProofBuilder::getDuplicatedStakeProofId(ProofBuilder &pb) {
+    CHashWriter ss(SER_GETHASH, 0);
+    ss << pb.sequence;
+    ss << pb.expirationTime;
+
+    WriteCompactSize(ss, 2 * pb.stakes.size());
     for (auto &s : pb.stakes) {
-        signedStakes.push_back(s.sign(proofid));
+        ss << s.stake;
+        ss << s.stake;
+    }
+
+    CHashWriter ss2(SER_GETHASH, 0);
+    ss2 << ss.GetHash();
+    ss2 << pb.master;
+
+    return ProofId(ss2.GetHash());
+}
+
+Proof TestProofBuilder::buildDuplicatedStakes(ProofBuilder &pb) {
+    const ProofId proofid = TestProofBuilder::getDuplicatedStakeProofId(pb);
+
+    std::vector<SignedStake> signedStakes;
+    signedStakes.reserve(2 * pb.stakes.size());
+
+    while (!pb.stakes.empty()) {
+        auto handle = pb.stakes.extract(pb.stakes.begin());
+        SignedStake signedStake = handle.value().sign(proofid);
+        signedStakes.push_back(signedStake);
+        signedStakes.push_back(signedStake);
     }
 
-    pb.stakes.clear();
     return Proof(pb.sequence, pb.expirationTime, std::move(pb.master),
                  std::move(signedStakes));
 }
 
 } // namespace avalanche
diff --git a/src/avalanche/test/util.h b/src/avalanche/test/util.h
index ec602ba19..a04d1f33d 100644
--- a/src/avalanche/test/util.h
+++ b/src/avalanche/test/util.h
@@ -1,29 +1,31 @@
 // Copyright (c) 2020 The Bitcoin developers
 // Distributed under the MIT software license, see the accompanying
 // file COPYING or http://www.opensource.org/licenses/mit-license.php.
 
 #ifndef BITCOIN_AVALANCHE_TEST_UTIL_H
 #define BITCOIN_AVALANCHE_TEST_UTIL_H
 
 #include <avalanche/proof.h>
 #include <avalanche/proofbuilder.h>
 #include <pubkey.h>
 
 #include <cstdio>
 
 namespace avalanche {
 
 constexpr uint32_t MIN_VALID_PROOF_SCORE = 100 * PROOF_DUST_THRESHOLD / COIN;
 
 Proof buildRandomProof(uint32_t score, const CPubKey &master = CPubKey());
 
 bool hasDustStake(const Proof &proof);
 
 struct TestProofBuilder {
     static ProofId getReverseOrderProofId(ProofBuilder &pb);
     static Proof buildWithReversedOrderStakes(ProofBuilder &pb);
+    static ProofId getDuplicatedStakeProofId(ProofBuilder &pb);
+    static Proof buildDuplicatedStakes(ProofBuilder &pb);
 };
 
 } // namespace avalanche
 
 #endif // BITCOIN_AVALANCHE_TEST_UTIL_H
diff --git a/test/functional/abc_rpc_avalancheproof.py b/test/functional/abc_rpc_avalancheproof.py
index c179dcb4e..97dd851a5 100644
--- a/test/functional/abc_rpc_avalancheproof.py
+++ b/test/functional/abc_rpc_avalancheproof.py
@@ -1,469 +1,480 @@
 #!/usr/bin/env python3
 # Copyright (c) 2021 The Bitcoin developers
 # Distributed under the MIT software license, see the accompanying
 # file COPYING or http://www.opensource.org/licenses/mit-license.php.
 """Test building avalanche proofs and using them to add avalanche peers."""
 import base64
 from decimal import Decimal
 
 from test_framework.address import ADDRESS_ECREG_UNSPENDABLE
 from test_framework.avatools import (
     create_coinbase_stakes,
     create_stakes,
     get_proof_ids,
     wait_for_proof,
 )
 from test_framework.key import ECKey
 from test_framework.messages import (
     AvalancheDelegation,
     AvalancheDelegationLevel,
     AvalancheProof,
     FromHex,
 )
 from test_framework.p2p import P2PInterface, p2p_lock
 from test_framework.test_framework import BitcoinTestFramework
 from test_framework.test_node import ErrorMatch
 from test_framework.util import (
     append_config,
     assert_equal,
     connect_nodes,
     wait_until,
     assert_raises_rpc_error,
 )
 from test_framework.wallet_util import bytes_to_wif
 
 AVALANCHE_MAX_PROOF_STAKES = 1000
 
 PROOF_DUST_THRESHOLD = 1000000.0
 """Minimum amount per UTXO in a proof (in coins, not in satoshis)"""
 
 
 def add_interface_node(test_node) -> str:
     """Create a mininode, connect it to test_node, return the nodeid
     of the mininode as registered by test_node.
     """
     n = P2PInterface()
     test_node.add_p2p_connection(n)
     n.wait_for_verack()
     return test_node.getpeerinfo()[-1]['id']
 
 
 class AvalancheProofTest(BitcoinTestFramework):
     def set_test_params(self):
         self.setup_clean_chain = True
         self.num_nodes = 2
         self.extra_args = [['-enableavalanche=1', '-avacooldown=0'],
                            ['-enableavalanche=1', '-avacooldown=0']]
         self.supports_cli = False
         self.rpc_timeout = 120
 
     def run_test(self):
         # Turn off node 1 while node 0 mines blocks to generate stakes,
         # so that we can later try starting node 1 with an orphan proof.
         self.stop_node(1)
 
         node = self.nodes[0]
 
         addrkey0 = node.get_deterministic_priv_key()
         blockhashes = node.generatetoaddress(100, addrkey0.address)
 
         self.log.info(
             "Make build a valid proof and restart the node to use it")
         privkey = ECKey()
         privkey.set(bytes.fromhex(
             "12b004fff7f4b69ef8650e767f18f11ede158148b425660723b9f9a66e61f747"), True)
 
         def get_hex_pubkey(privkey):
             return privkey.get_pubkey().get_bytes().hex()
 
         proof_master = get_hex_pubkey(privkey)
         proof_sequence = 11
         proof_expiration = 12
         stakes = create_coinbase_stakes(node, [blockhashes[0]], addrkey0.key)
         proof = node.buildavalancheproof(
             proof_sequence, proof_expiration, proof_master, stakes)
 
         self.log.info("Test decodeavalancheproof RPC")
         proofobj = FromHex(AvalancheProof(), proof)
         decodedproof = node.decodeavalancheproof(proof)
         limited_id_hex = f"{proofobj.limited_proofid:0{64}x}"
         assert_equal(decodedproof["sequence"], proof_sequence)
         assert_equal(decodedproof["expiration"], proof_expiration)
         assert_equal(decodedproof["master"], proof_master)
         assert_equal(decodedproof["proofid"], f"{proofobj.proofid:0{64}x}")
         assert_equal(decodedproof["limitedid"], limited_id_hex)
         assert_equal(decodedproof["stakes"][0]["txid"], stakes[0]["txid"])
         assert_equal(decodedproof["stakes"][0]["vout"], stakes[0]["vout"])
         assert_equal(decodedproof["stakes"][0]["height"], stakes[0]["height"])
         assert_equal(
             decodedproof["stakes"][0]["iscoinbase"],
             stakes[0]["iscoinbase"])
         assert_equal(
             decodedproof["stakes"][0]["signature"],
             base64.b64encode(proofobj.stakes[0].sig).decode("ascii"))
 
         # Invalid hex (odd number of hex digits)
         assert_raises_rpc_error(-22, "Proof must be an hexadecimal string",
                                 node.decodeavalancheproof, proof[:-1])
         # Valid hex but invalid proof
         assert_raises_rpc_error(-22, "Proof has invalid format",
                                 node.decodeavalancheproof, proof[:-2])
 
         # Restart the node with this proof
         self.restart_node(0, self.extra_args[0] + [
             "-avaproof={}".format(proof),
             "-avamasterkey=cND2ZvtabDbJ1gucx9GWH6XT9kgTAqfb6cotPt5Q5CyxVDhid2EN",
         ])
 
         self.log.info("The proof is registered at first chaintip update")
         assert_equal(len(node.getavalanchepeerinfo()), 0)
         node.generate(1)
         wait_until(lambda: len(node.getavalanchepeerinfo()) == 1, timeout=5)
 
         # This case will occur for users building proofs with a third party
         # tool and then starting a new node that is not yet aware of the
         # transactions used for stakes.
         self.log.info("Start a node with an orphan proof")
 
         self.start_node(1, self.extra_args[0] + [
             "-avaproof={}".format(proof),
             "-avamasterkey=cND2ZvtabDbJ1gucx9GWH6XT9kgTAqfb6cotPt5Q5CyxVDhid2EN",
         ])
         # Mine a block to trigger an attempt at registering the proof
         self.nodes[1].generate(1)
         wait_for_proof(self.nodes[1], f"{proofobj.proofid:0{64}x}",
                        expect_orphan=True)
 
         self.log.info("Connect to an up-to-date node to unorphan the proof")
         connect_nodes(self.nodes[1], node)
         self.sync_all()
         wait_for_proof(self.nodes[1], f"{proofobj.proofid:0{64}x}",
                        expect_orphan=False)
 
         self.log.info("Generate delegations for the proof")
 
         # Stack up a few delegation levels
         def gen_privkey():
             pk = ECKey()
             pk.generate()
             return pk
 
         delegator_privkey = privkey
         delegation = None
         for _ in range(10):
             delegated_privkey = gen_privkey()
             delegation = node.delegateavalancheproof(
                 limited_id_hex,
                 bytes_to_wif(delegator_privkey.get_bytes()),
                 get_hex_pubkey(delegated_privkey),
                 delegation,
             )
             delegator_privkey = delegated_privkey
 
         random_privkey = gen_privkey()
         random_pubkey = get_hex_pubkey(random_privkey)
 
         # Invalid proof
         no_stake = node.buildavalancheproof(proof_sequence, proof_expiration,
                                             proof_master, [])
 
         # Invalid privkey
         assert_raises_rpc_error(-5, "The private key is invalid",
                                 node.delegateavalancheproof,
                                 limited_id_hex,
                                 bytes_to_wif(bytes(32)),
                                 random_pubkey,
                                 )
 
         # Invalid delegation
         bad_dg = AvalancheDelegation()
         assert_raises_rpc_error(-8, "The delegation does not match the proof",
                                 node.delegateavalancheproof,
                                 limited_id_hex,
                                 bytes_to_wif(privkey.get_bytes()),
                                 random_pubkey,
                                 bad_dg.serialize().hex(),
                                 )
 
         # Still invalid, but with a matching proofid
         bad_dg.limited_proofid = proofobj.limited_proofid
         bad_dg.proof_master = proofobj.master
         bad_dg.levels = [AvalancheDelegationLevel()]
         assert_raises_rpc_error(-8, "The delegation is invalid",
                                 node.delegateavalancheproof,
                                 limited_id_hex,
                                 bytes_to_wif(privkey.get_bytes()),
                                 random_pubkey,
                                 bad_dg.serialize().hex(),
                                 )
 
         # Wrong privkey, match the proof but does not match the delegation
         assert_raises_rpc_error(-5, "The private key does not match the delegation",
                                 node.delegateavalancheproof,
                                 limited_id_hex,
                                 bytes_to_wif(privkey.get_bytes()),
                                 random_pubkey,
                                 delegation,
                                 )
 
         # Delegation not hex
         assert_raises_rpc_error(-22, "Delegation must be an hexadecimal string.",
                                 node.delegateavalancheproof,
                                 limited_id_hex,
                                 bytes_to_wif(privkey.get_bytes()),
                                 random_pubkey,
                                 "f00",
                                 )
         # Delegation is hex but ill-formed
         assert_raises_rpc_error(-22, "Delegation has invalid format",
                                 node.delegateavalancheproof,
                                 limited_id_hex,
                                 bytes_to_wif(privkey.get_bytes()),
                                 random_pubkey,
                                 "dead",
                                 )
 
         # Test invalid proofs
         dust = node.buildavalancheproof(
             proof_sequence, proof_expiration, proof_master,
             create_coinbase_stakes(node, [blockhashes[0]], addrkey0.key, amount="0"))
 
         dust_amount = Decimal(f"{PROOF_DUST_THRESHOLD * 0.9999:.4f}")
         dust2 = node.buildavalancheproof(
             proof_sequence, proof_expiration, proof_master,
             create_coinbase_stakes(node, [blockhashes[0]], addrkey0.key,
                                    amount=str(dust_amount)))
 
-        duplicate_stake = node.buildavalancheproof(
-            proof_sequence, proof_expiration, proof_master,
-            create_coinbase_stakes(node, [blockhashes[0]] * 2, addrkey0.key))
-
         missing_stake = node.buildavalancheproof(
             proof_sequence, proof_expiration, proof_master, [{
                 'txid': '0' * 64,
                 'vout': 0,
                 'amount': 10000000,
                 'height': 42,
                 'iscoinbase': False,
                 'privatekey': addrkey0.key,
             }]
         )
 
+        duplicate_stake = ("0b000000000000000c0000000000000021030b4c866585dd868"
+                           "a9d62348a9cd008d6a312937048fff31670e7e920cfc7a74402"
+                           "05c5f72f5d6da3085583e75ee79340eb4eff208c89988e7ed0e"
+                           "fb30b87298fa30000000000f2052a0100000003000000210227"
+                           "d85ba011276cf25b51df6a188b75e604b38770a462b2d0e9fb2"
+                           "fc839ef5d3f86076def2e8bc3c40671c1a0eb505da5857a950a"
+                           "0cf4625a80018cdd75ac62e61273ff8142f747de67e73f6368c"
+                           "8648942b0ef6c065d72a81ad7438a23c11cca05c5f72f5d6da3"
+                           "085583e75ee79340eb4eff208c89988e7ed0efb30b87298fa30"
+                           "000000000f2052a0100000003000000210227d85ba011276cf2"
+                           "5b51df6a188b75e604b38770a462b2d0e9fb2fc839ef5d3f860"
+                           "76def2e8bc3c40671c1a0eb505da5857a950a0cf4625a80018c"
+                           "dd75ac62e61273ff8142f747de67e73f6368c8648942b0ef6c0"
+                           "65d72a81ad7438a23c11cca")
+
         bad_sig = ("0b000000000000000c0000000000000021030b4c866585dd868a9d62348"
                    "a9cd008d6a312937048fff31670e7e920cfc7a7440105c5f72f5d6da3085"
                    "583e75ee79340eb4eff208c89988e7ed0efb30b87298fa30000000000f20"
                    "52a0100000003000000210227d85ba011276cf25b51df6a188b75e604b3"
                    "8770a462b2d0e9fb2fc839ef5d3faf07f001dd38e9b4a43d07d5d449cc0"
                    "f7d2888d96b82962b3ce516d1083c0e031773487fc3c4f2e38acd1db974"
                    "1321b91a79b82d1c2cfd47793261e4ba003cf5")
 
         wrong_order = ("c964aa6fde575e4ce8404581c7be874e21023beefdde700a6bc0203"
                        "6335b4df141c8bc67bb05a971f5ac2745fd683797dde30305d427b7"
                        "06705a5d4b6a368a231d6db62abacf8c29bc32b61e7f65a0a6976aa"
                        "8b86b687bc0260e821e4f0200b9d3bf6d2102449fb5237efe8f647d"
                        "32e8b64f06c22d1d40368eaca2a71ffc6a13ecc8bce68052365271b"
                        "6c71189f5cd7e3b694b77b579080f0b35bae567b96590ab6aa3019b"
                        "018ff9f061f52f1426bdb195d4b6d4dff5114cee90e33dabf0c588e"
                        "badf7774418f54247f6390791706af36fac782302479898b5273f9e"
                        "51a92cb1fb5af43deeb6c8c269403d30ffcb380300134398c42103e"
                        "49f9df52de2dea81cf7838b82521b69f2ea360f1c4eed9e6c89b7d0"
                        "f9e645efa08e97ea0c60e1f0a064fbf08989c084707082727e85dcb"
                        "9f79bb503f76ee6c8dad42a07ef15c89b3750a5631d604b21fafff0"
                        "f4de354ade95c2f28160ae549af0d4ce48c4ca9d0714b1fa5192027"
                        "0f8575e0af610f07b4e602a018ecdbb649b64fff614c0026e9fc8e0"
                        "030092533d422103aac52f4cfca700e7e9824298e0184755112e32f"
                        "359c832f5f6ad2ef62a2c024af812d6d7f2ecc6223a774e19bce1fb"
                        "20d94d6b01ea693638f55c74fdaa5358fa9239d03e4caf3d817e8f7"
                        "48ccad55a27b9d365db06ad5a0b779ac385f3dc8710")
 
         self.log.info(
             "Check the verifyavalancheproof and sendavalancheproof RPCs")
 
         if self.is_wallet_compiled():
             self.log.info(
                 "Check a proof with the maximum number of UTXO is valid")
             new_blocks = node.generate(AVALANCHE_MAX_PROOF_STAKES // 10 + 1)
             # confirm the coinbase UTXOs
             node.generate(101)
             too_many_stakes = create_stakes(
                 node, new_blocks, AVALANCHE_MAX_PROOF_STAKES + 1)
             maximum_stakes = too_many_stakes[:-1]
 
             good_proof = node.buildavalancheproof(
                 proof_sequence, proof_expiration,
                 proof_master, maximum_stakes)
 
             too_many_utxos = node.buildavalancheproof(
                 proof_sequence, proof_expiration,
                 proof_master, too_many_stakes)
 
             assert node.verifyavalancheproof(good_proof)
 
         for rpc in [node.verifyavalancheproof, node.sendavalancheproof]:
             assert_raises_rpc_error(-22, "Proof must be an hexadecimal string",
                                     rpc, "f00")
             assert_raises_rpc_error(-22, "Proof has invalid format",
                                     rpc, "f00d")
 
             def check_rpc_failure(proof, message):
                 assert_raises_rpc_error(-8, "The proof is invalid: " + message,
                                         rpc, proof)
 
             check_rpc_failure(no_stake, "no-stake")
             check_rpc_failure(dust, "amount-below-dust-threshold")
             check_rpc_failure(duplicate_stake, "duplicated-stake")
             check_rpc_failure(missing_stake, "utxo-missing-or-spent")
             check_rpc_failure(bad_sig, "invalid-signature")
             check_rpc_failure(wrong_order, "wrong-stake-ordering")
             if self.is_wallet_compiled():
                 check_rpc_failure(too_many_utxos, "too-many-utxos")
 
         conflicting_utxo = node.buildavalancheproof(
             proof_sequence + 1, proof_expiration, proof_master, stakes)
         assert_raises_rpc_error(-8, "The proof has conflicting utxo with an existing proof",
                                     node.sendavalancheproof, conflicting_utxo)
 
         # Good proof
         assert node.verifyavalancheproof(proof)
 
         peer = node.add_p2p_connection(P2PInterface())
 
         proofid = FromHex(AvalancheProof(), proof).proofid
         node.sendavalancheproof(proof)
         assert proofid in get_proof_ids(node)
 
         def inv_found():
             with p2p_lock:
                 return peer.last_message.get(
                     "inv") and peer.last_message["inv"].inv[-1].hash == proofid
         wait_until(inv_found)
 
         self.log.info("Check the getrawproof RPC")
 
         raw_proof = node.getrawavalancheproof("{:064x}".format(proofid))
         assert_equal(raw_proof['proof'], proof)
         assert_equal(raw_proof['orphan'], False)
 
         assert_raises_rpc_error(-8, "Proof not found",
                                 node.getrawavalancheproof, '0' * 64)
 
         # Orphan the proof by sending the stake
         raw_tx = node.createrawtransaction(
             [{"txid": stakes[-1]["txid"], "vout": 0}],
             {ADDRESS_ECREG_UNSPENDABLE: stakes[-1]
                 ["amount"] - Decimal('10000')}
         )
         signed_tx = node.signrawtransactionwithkey(raw_tx, [addrkey0.key])
         node.sendrawtransaction(signed_tx["hex"])
         node.generate(1)
         wait_until(lambda: proofid not in get_proof_ids(node))
 
         raw_proof = node.getrawavalancheproof("{:064x}".format(proofid))
         assert_equal(raw_proof['proof'], proof)
         assert_equal(raw_proof['orphan'], True)
 
         self.log.info("Bad proof should be rejected at startup")
 
         self.stop_node(0)
 
         node.assert_start_raises_init_error(
             self.extra_args[0] + [
                 "-avasessionkey=0",
             ],
             expected_msg="Error: The avalanche session key is invalid.",
         )
 
         node.assert_start_raises_init_error(
             self.extra_args[0] + [
                 "-avaproof={}".format(proof),
             ],
             expected_msg="Error: The avalanche master key is missing for the avalanche proof.",
         )
 
         node.assert_start_raises_init_error(
             self.extra_args[0] + [
                 "-avaproof={}".format(proof),
                 "-avamasterkey=0",
             ],
             expected_msg="Error: The avalanche master key is invalid.",
         )
 
         def check_proof_init_error(proof, message):
             node.assert_start_raises_init_error(
                 self.extra_args[0] + [
                     "-avaproof={}".format(proof),
                     "-avamasterkey=cND2ZvtabDbJ1gucx9GWH6XT9kgTAqfb6cotPt5Q5CyxVDhid2EN",
                 ],
                 expected_msg="Error: " + message,
             )
 
         check_proof_init_error(no_stake,
                                "The avalanche proof has no stake.")
         check_proof_init_error(dust,
                                "The avalanche proof stake is too low.")
         check_proof_init_error(dust2,
                                "The avalanche proof stake is too low.")
         check_proof_init_error(duplicate_stake,
                                "The avalanche proof has duplicated stake.")
         check_proof_init_error(bad_sig,
                                "The avalanche proof has invalid stake signatures.")
         if self.is_wallet_compiled():
             # The too many utxos case creates a proof which is that large that it
             # cannot fit on the command line
             append_config(node.datadir, ["avaproof={}".format(too_many_utxos)])
             node.assert_start_raises_init_error(
                 self.extra_args[0] + [
                     "-avamasterkey=cND2ZvtabDbJ1gucx9GWH6XT9kgTAqfb6cotPt5Q5CyxVDhid2EN",
                 ],
                 expected_msg="Error: The avalanche proof has too many utxos.",
                 match=ErrorMatch.PARTIAL_REGEX,
             )
 
         # Master private key mismatch
         random_privkey = ECKey()
         random_privkey.generate()
         node.assert_start_raises_init_error(
             self.extra_args[0] + [
                 "-avaproof={}".format(proof),
                 "-avamasterkey={}".format(
                     bytes_to_wif(random_privkey.get_bytes())),
             ],
             expected_msg="Error: The master key does not match the proof public key.",
         )
 
         self.log.info("Bad delegation should be rejected at startup")
 
         def check_delegation_init_error(delegation, message):
             node.assert_start_raises_init_error(
                 self.extra_args[0] + [
                     "-avadelegation={}".format(delegation),
                     "-avaproof={}".format(proof),
                     "-avamasterkey={}".format(
                         bytes_to_wif(delegated_privkey.get_bytes())),
                 ],
                 expected_msg="Error: " + message,
             )
 
         check_delegation_init_error(
             AvalancheDelegation().serialize().hex(),
             "The delegation does not match the proof.")
 
         bad_level_sig = FromHex(AvalancheDelegation(), delegation)
         # Tweak some key to cause the signature to mismatch
         bad_level_sig.levels[-2].pubkey = bytes.fromhex(proof_master)
         check_delegation_init_error(bad_level_sig.serialize().hex(),
                                     "The avalanche delegation has invalid signatures.")
 
         node.assert_start_raises_init_error(
             self.extra_args[0] + [
                 "-avadelegation={}".format(delegation),
                 "-avaproof={}".format(proof),
                 "-avamasterkey={}".format(
                     bytes_to_wif(random_privkey.get_bytes())),
             ],
             expected_msg="Error: The master key does not match the delegation public key.",
         )
 
 
 if __name__ == '__main__':
     AvalancheProofTest().main()