diff --git a/src/avalanche/proof.cpp b/src/avalanche/proof.cpp
index 6692da69c..871f70824 100644
--- a/src/avalanche/proof.cpp
+++ b/src/avalanche/proof.cpp
@@ -1,134 +1,132 @@
 // 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/validation.h>
 #include <coins.h>
 #include <hash.h>
 #include <script/standard.h>
 
 #include <unordered_set>
 
 namespace avalanche {
 
 uint256 Stake::getHash(const ProofId &proofid) const {
     CHashWriter ss(SER_GETHASH, 0);
     ss << proofid;
     ss << *this;
     return ss.GetHash();
 }
 
 bool SignedStake::verify(const ProofId &proofid) const {
     return stake.getPubkey().VerifySchnorr(stake.getHash(proofid), sig);
 }
 
 ProofId Proof::computeProofId() const {
     CHashWriter ss(SER_GETHASH, 0);
     ss << sequence;
     ss << expirationTime;
     ss << master;
 
     WriteCompactSize(ss, stakes.size());
     for (const SignedStake &s : stakes) {
         ss << s.getStake();
     }
 
     return ProofId(ss.GetHash());
 }
 
 uint32_t Proof::getScore() const {
     Amount total = Amount::zero();
     for (const SignedStake &s : stakes) {
         total += s.getStake().getAmount();
     }
 
     return uint32_t((100 * total) / COIN);
 }
 
-static constexpr Amount PROOF_DUST_THRESOLD = 1 * SATOSHI;
-
 bool Proof::verify(ProofValidationState &state) const {
     if (stakes.empty()) {
         return state.Invalid(ProofValidationResult::NO_STAKE);
     }
 
     if (stakes.size() > AVALANCHE_MAX_PROOF_STAKES) {
         return state.Invalid(ProofValidationResult::TOO_MANY_UTXOS);
     }
 
     std::unordered_set<COutPoint, SaltedOutpointHasher> utxos;
     for (const SignedStake &ss : stakes) {
         const Stake &s = ss.getStake();
-        if (s.getAmount() < PROOF_DUST_THRESOLD) {
+        if (s.getAmount() < PROOF_DUST_THRESHOLD) {
             return state.Invalid(ProofValidationResult::DUST_THRESOLD);
         }
 
         if (!utxos.insert(s.getUTXO()).second) {
             return state.Invalid(ProofValidationResult::DUPLICATE_STAKE);
         }
 
         if (!ss.verify(proofid)) {
             return state.Invalid(ProofValidationResult::INVALID_SIGNATURE);
         }
     }
 
     return true;
 }
 
 bool Proof::verify(ProofValidationState &state, const CCoinsView &view) const {
     if (!verify(state)) {
         // state is set by verify.
         return false;
     }
 
     for (const SignedStake &ss : stakes) {
         const Stake &s = ss.getStake();
         const COutPoint &utxo = s.getUTXO();
 
         Coin coin;
         if (!view.GetCoin(utxo, coin)) {
             // The coins are not in the UTXO set.
             return state.Invalid(ProofValidationResult::MISSING_UTXO);
         }
 
         if (s.isCoinbase() != coin.IsCoinBase()) {
             return state.Invalid(ProofValidationResult::COINBASE_MISMATCH);
         }
 
         if (s.getHeight() != coin.GetHeight()) {
             return state.Invalid(ProofValidationResult::HEIGHT_MISMATCH);
         }
 
         const CTxOut &out = coin.GetTxOut();
         if (s.getAmount() != out.nValue) {
             // Wrong amount.
             return state.Invalid(ProofValidationResult::AMOUNT_MISMATCH);
         }
 
         CTxDestination dest;
         if (!ExtractDestination(out.scriptPubKey, dest)) {
             // Can't extract destination.
             return state.Invalid(
                 ProofValidationResult::NON_STANDARD_DESTINATION);
         }
 
         PKHash *pkhash = boost::get<PKHash>(&dest);
         if (!pkhash) {
             // Only PKHash are supported.
             return state.Invalid(
                 ProofValidationResult::DESTINATION_NOT_SUPPORTED);
         }
 
         const CPubKey &pubkey = s.getPubkey();
         if (*pkhash != PKHash(pubkey)) {
             // Wrong pubkey.
             return state.Invalid(ProofValidationResult::DESTINATION_MISMATCH);
         }
     }
 
     return true;
 }
 
 } // namespace avalanche
diff --git a/src/avalanche/proof.h b/src/avalanche/proof.h
index 83a438529..442d131cd 100644
--- a/src/avalanche/proof.h
+++ b/src/avalanche/proof.h
@@ -1,110 +1,113 @@
 // 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_PROOF_H
 #define BITCOIN_AVALANCHE_PROOF_H
 
 #include <amount.h>
 #include <avalanche/proofid.h>
 #include <key.h>
 #include <primitives/transaction.h>
 #include <pubkey.h>
 #include <serialize.h>
 
 #include <array>
 #include <cstdint>
 #include <vector>
 
 class CCoinsView;
 
 /**
  * How many UTXOs can be used for a single proof.
  */
 static constexpr int AVALANCHE_MAX_PROOF_STAKES = 1000;
 
 namespace avalanche {
 
+/** Minimum amount per utxo */
+static constexpr Amount PROOF_DUST_THRESHOLD = 1 * COIN;
+
 class ProofValidationState;
 
 class Stake {
     COutPoint utxo;
 
     Amount amount;
     uint32_t height;
     CPubKey pubkey;
 
 public:
     explicit Stake() = default;
     Stake(COutPoint utxo_, Amount amount_, uint32_t height_, bool is_coinbase,
           CPubKey pubkey_)
         : utxo(utxo_), amount(amount_), height(height_ << 1 | is_coinbase),
           pubkey(std::move(pubkey_)) {}
 
     SERIALIZE_METHODS(Stake, obj) {
         READWRITE(obj.utxo, obj.amount, obj.height, obj.pubkey);
     }
 
     const COutPoint &getUTXO() const { return utxo; }
     Amount getAmount() const { return amount; }
     uint32_t getHeight() const { return height >> 1; }
     bool isCoinbase() const { return height & 1; }
     const CPubKey &getPubkey() const { return pubkey; }
 
     uint256 getHash(const ProofId &proofid) const;
 };
 
 class SignedStake {
     Stake stake;
     SchnorrSig sig;
 
 public:
     explicit SignedStake() = default;
     SignedStake(Stake stake_, SchnorrSig sig_)
         : stake(std::move(stake_)), sig(std::move(sig_)) {}
 
     SERIALIZE_METHODS(SignedStake, obj) { READWRITE(obj.stake, obj.sig); }
 
     const Stake &getStake() const { return stake; }
     const SchnorrSig &getSignature() const { return sig; }
 
     bool verify(const ProofId &proofid) const;
 };
 
 class Proof {
     uint64_t sequence;
     int64_t expirationTime;
     CPubKey master;
     std::vector<SignedStake> stakes;
 
     ProofId proofid;
     ProofId computeProofId() const;
 
 public:
     Proof() : sequence(0), expirationTime(0), master(), stakes(), proofid() {}
     Proof(uint64_t sequence_, int64_t expirationTime_, CPubKey master_,
           std::vector<SignedStake> stakes_)
         : sequence(sequence_), expirationTime(expirationTime_),
           master(std::move(master_)), stakes(std::move(stakes_)),
           proofid(computeProofId()) {}
 
     SERIALIZE_METHODS(Proof, obj) {
         READWRITE(obj.sequence, obj.expirationTime, obj.master, obj.stakes);
         SER_READ(obj, obj.proofid = obj.computeProofId());
     }
 
     uint64_t getSequence() const { return sequence; }
     int64_t getExpirationTime() const { return expirationTime; }
     const CPubKey &getMaster() const { return master; }
     const std::vector<SignedStake> &getStakes() const { return stakes; }
 
     const ProofId &getId() const { return proofid; }
     uint32_t getScore() const;
 
     bool verify(ProofValidationState &state) const;
     bool verify(ProofValidationState &state, const CCoinsView &view) const;
 };
 
 } // namespace avalanche
 
 #endif // BITCOIN_AVALANCHE_PROOF_H
diff --git a/src/avalanche/test/peermanager_tests.cpp b/src/avalanche/test/peermanager_tests.cpp
index bce3e908d..f007bbc12 100644
--- a/src/avalanche/test/peermanager_tests.cpp
+++ b/src/avalanche/test/peermanager_tests.cpp
@@ -1,441 +1,441 @@
 // 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;
 
 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));
         }
     }
 }
 
 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.
-    Proof proof0 = buildRandomProof(100);
+    Proof proof0 = buildRandomProof(MIN_VALID_PROOF_SCORE);
     Delegation dg0 = DelegationBuilder(proof0).build();
     pm.addNode(node0, proof0, dg0);
     BOOST_CHECK_EQUAL(pm.selectNode(), node0);
 
     // Two peers, verify ratio.
-    Proof proof1 = buildRandomProof(200);
+    Proof proof1 = buildRandomProof(2 * MIN_VALID_PROOF_SCORE);
     Delegation dg1 = DelegationBuilder(proof1).build();
     pm.addNode(node1, proof1, dg1);
 
     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.
-    Proof proof2 = buildRandomProof(100);
+    Proof proof2 = buildRandomProof(MIN_VALID_PROOF_SCORE);
     Delegation dg2 = DelegationBuilder(proof2).build();
     pm.addNode(node2, proof2, dg2);
 
     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++) {
         Proof p = buildRandomProof(100);
         peerids[i] = pm.getPeerId(p);
         BOOST_CHECK(
             pm.addNode(InsecureRand32(), p, DelegationBuilder(p).build()));
     }
 
     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++) {
         Proof p = buildRandomProof(100);
         peerids[i + 4] = pm.getPeerId(p);
         BOOST_CHECK(
             pm.addNode(InsecureRand32(), p, DelegationBuilder(p).build()));
     }
 
     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++) {
         Proof p = buildRandomProof(100);
         peerids[i] = pm.getPeerId(p);
         BOOST_CHECK(
             pm.addNode(InsecureRand32(), p, DelegationBuilder(p).build()));
     }
 
     // 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.
-    Proof proof = buildRandomProof(100000000);
+    Proof proof = buildRandomProof(10000000 * MIN_VALID_PROOF_SCORE);
     Delegation dg = DelegationBuilder(proof).build();
     BOOST_CHECK_EQUAL(pm.selectNode(), NO_NODE);
 
     // Add 4 nodes.
     for (int i = 0; i < 4; i++) {
         BOOST_CHECK(pm.addNode(i, proof, dg));
     }
 
     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 a billion.
-    Proof altproof = buildRandomProof(1);
+    // as chances of being picked are 1 in 10 million.
+    Proof altproof = buildRandomProof(MIN_VALID_PROOF_SCORE);
     Delegation altdg = DelegationBuilder(altproof).build();
     BOOST_CHECK(pm.addNode(3, altproof, altdg));
 
     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(proof_conflict) {
     CKey key;
     key.MakeNewKey(true);
     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(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);
 
     // 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_SUITE_END()
diff --git a/src/avalanche/test/proof_tests.cpp b/src/avalanche/test/proof_tests.cpp
index e28e20ab1..42b2b0c2c 100644
--- a/src/avalanche/test/proof_tests.cpp
+++ b/src/avalanche/test/proof_tests.cpp
@@ -1,449 +1,465 @@
 // 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(p.verify(state));
-        BOOST_CHECK(state.GetResult() == ProofValidationResult::NONE);
+        BOOST_CHECK_EQUAL(p.verify(state),
+                          state.GetResult() == ProofValidationResult::NONE);
+        BOOST_CHECK(state.GetResult() == expected_state);
     }
 }
 
 BOOST_AUTO_TEST_CASE(proofbuilder) {
     CKey key;
 
     // Master key.
     key.MakeNewKey(true);
     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("df721b6e2a857ce8abac63d8d5eca35f3bdb0293b6e8295942c7"
                           "6274c5418c0c"),
          0, ProofValidationResult::NO_STAKE},
         {"1 utxo staked",
          "a6d66db9fe9378fdd37a0ad2c01c2acd2103648144bb6a0c1d09b0f04d0df6d55f914"
          "fd81efc65f23a718b68b7c9e42bd5430145a4d07798547464daa53acefb7c97c0c415"
          "ed8e81e549ff56a0ef6f847fcc9ca855b36200fe38dce5060000e707d7274104fb662"
          "6e21dbd1cc9feeecdefc9213fdce2b51ac4bb44e1f8dc6f14c2052f5dd7bfaeb2267a"
          "97ca2bec6e0dd4acf50a66204bde1ebb5d6c551684cff2f939920f7fbb2efd860d6d5"
          "926bf425eb47b78bf6979cdcd67eb705e2c9a4d45a0930ba25463178a3fb99cb28c8b"
          "77d8fcf68c54ebfadf08b9a446c251a0088301c50d53",
          ProofId::fromHex("048235ee870030f11c287d898dd3ec184f9b38cf4fb274334966"
                           "c6aad83b769d"),
          7584312, ProofValidationResult::INVALID_SIGNATURE},
         {"2 utxo staked",
          "872379ab64f55b4166ca0e79639999ec4104a66861de557a54eefc0375264cc17c3a3"
          "50ccabca6fd9c91883e899ab55bb140517aa56c5b4041908e7027a786b99f66488a04"
          "135ce5fe189a99a7bc541ddfe602fabf3ad5b875840e7813a66d5ea8a1288a49b6222"
          "b59fcbe6249f94e5927f9f4b884b0b040a534b3ba040000d045d5d021036830e697b0"
          "ee89866da798a8945bd85b352545ec1bcace7e04909ea54c134f16d5fe4e972b7acd2"
          "9ebfc2b7b11c26974b84e5f21a45bbe8372472f59e5dfdea7e9e5857c6aebe5dbc5e6"
          "46dfbf4e7cee380afaddb15d06153bf1755b9ef00a616d4c8c3c3a662b5eddc192656"
          "4a488e3e68e334291078001480f7fa5144ef3a606a41e85c0218dd377090000e41099"
          "912102ebfcea8e1864c1273c41e0d7c1e9097be5c491bbbf5fe31161d8e5589b9d6b5"
          "b12f3b963c7fc7614d56d83af907e5cb18ac2f4c3e70a8c4253995f6bc002ec5e3504"
          "91c965cba4dbc11c210979217f1ac3ece7a748f5b2fcf5cced40a5d4c40e",
          ProofId::fromHex("7319126f0d4efc188440dd50105ea30d792687b65e9cdde6c4d6"
                           "08ed226cba00"),
          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("3b3204993240ab338324310ecadc5f234da1dac0627029cef63e"
                           "1169a049d18f"),
          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("62f256d73411fe69bf0db6083248e4efb75be9788850851468ac"
                           "c913c5c14360"),
          44059793, ProofValidationResult::INVALID_SIGNATURE},
         {"Properly signed 1 UTXO proof",
          "d97587e6c882615796011ec8f9a7b1c64104e556ba887297fd6a655bc2579d26814e8"
          "54c902448ec3ce3c6fe965e3420aa3f0e9611d3c0b8a73b6329741e2e726fd17f5e8a"
          "bd546a614b0e05433528b195870169a79ff23e1d58c64afad42ad81cffe53967e16be"
          "b692fc5776bb442c79c5d91de00cf21804712806594010038e168a34104d9d84ebf65"
          "22cf24c6fd4addedd068632a4db06c3cd6e40031c72d416e9eefbd90037383d8da9e9"
          "213a4818a02f108ac1656141ecfbfdde0aeb8620eb210c08b2ce587d9fec0799f9725"
          "5d2bc5a077c7b4e8ca8a68d6a0377abf0aa2473f97b37779431062dad50ef5fd21cf1"
          "7c0276a293ee5b3f5a130fc5f9b217585cae23e",
          ProofId::fromHex("17717dbf1cee175925be12321bb04eda7bc861a28b04d764c2d5"
                           "5eabf01cabd0"),
          444638638, ProofValidationResult::NONE},
         {"Duplicated UTXO",
          "60f8332a3ff3430a4f3c9010160cc63e2102f2df6361a5744521d16753f9efb5ace68"
          "d43121e90ff67290540b54341cbab0e02d1e26c2287948bc6ab2b55945c591b8ba3ff"
          "a237f5d9164d30a4f10145a61f788e639b1480731e2aead30500bf84628721029ed70"
          "5bdc5adf0444c57c5ec2ea929c1adc0cd5b9cef4647d85dcb7fc400dc3afd21b29571"
          "9c45b90fda493bbc74c8ae1baf28e124cc23bb1987f9932d2df5a0b3455e6c815767c"
          "be8ccdd04e0e2d33d5f2f092667ef081acdaafde869d58daed1e26c2287948bc6ab2b"
          "55945c591b8ba3ffa237f5d9164d30a4f10145a61f788e639b1480731e2aead30500b"
          "f84628721029ed705bdc5adf0444c57c5ec2ea929c1adc0cd5b9cef4647d85dcb7fc4"
          "00dc3afd21b295719c45b90fda493bbc74c8ae1baf28e124cc23bb1987f9932d2df5a"
          "0b3455e6c815767cbe8ccdd04e0e2d33d5f2f092667ef081acdaafde869d58dae",
          ProofId::fromHex("b0c2c07cbc766df0a934bcb252063ad5d7d5167b080369f6feca"
                           "a3aabae29785"),
          3280755132, ProofValidationResult::DUPLICATE_STAKE},
         {"Properly signed 3 UTXO proof",
          "c96492f9e27a25d7e8404581c7be874e210282eb68a587dc586673f439fe317fa0b76"
          "aceefa9f99820eadaa70d3b19c0cfe10305d427b706705a5d4b6a368a231d6db62aba"
          "cf8c29bc32b61e7f65a0a6976aa8b86b687bc0260e821e4f0200b9d3bf6d2102914b1"
          "aade61c7b5d38b18fb8c02ec4a9411858a43969927e5a2bf371e83ea20aa2a8ac89e9"
          "fb52edcb227de3c3bd51519c0afcd5c3c134f09e53a9dd4315d4cde560c54b5700c2e"
          "7b4f15c18461a3c093b790e93ef54640c051fff6798f18e2c18f54247f6390791706a"
          "f36fac782302479898b5273f9e51a92cb1fb5af43deeb6c8c269403dbd48c9530a001"
          "34398c441040a9c4426531e19916a0250536684073fbedce86d73e883ee1107e7984e"
          "7c721b2be965c63bcbdbd23dcabba6de7ae6715872c803a257e53b686ea69217228c0"
          "6ee1b88c4c7aa55adb1804a13e9d222b8d327c4de466fcd9e71ec20582f8d0760830a"
          "67e020688e73c91519bd4b74358e65e9ddc95065bcf1bee0d11767e10f30f0d4ce48c"
          "4ca9d0714b1fa51920270f8575e0af610f07b4e602a018ecdbb649b64fff614c0026e"
          "9fc8e0030092533d424104973b212564dfb8ff1aa4bab13389ed170ea6cbb06fd9a5b"
          "5b3e8c00d1a7d4bca7d237748ad793fc043b12f73a28caabb00927c5aea81e323d3ba"
          "047a9661adbb0728ccfb41ab345299d7469ff5ec259b98fc946c730b5100cc97284ea"
          "6101f7e43337987bbfe655754939709c72c7ba69a9dc08558733781ee9da34e3de7bd"
          "a7",
          ProofId::fromHex("5948d32ee26882a2d9f96c18e9e51ad13a79234b627a020ee7db"
                           "733684cb05a7"),
          353426051, ProofValidationResult::NONE},
         {"Changing sequence affect ProofId",
          "d87587e6c882615796011ec8f9a7b1c64104e556ba887297fd6a655bc2579d26814e8"
          "54c902448ec3ce3c6fe965e3420aa3f0e9611d3c0b8a73b6329741e2e726fd17f5e8a"
          "bd546a614b0e05433528b195870169a79ff23e1d58c64afad42ad81cffe53967e16be"
          "b692fc5776bb442c79c5d91de00cf21804712806594010038e168a34104d9d84ebf65"
          "22cf24c6fd4addedd068632a4db06c3cd6e40031c72d416e9eefbd90037383d8da9e9"
          "213a4818a02f108ac1656141ecfbfdde0aeb8620eb210c08b2ce587d9fec0799f9725"
          "5d2bc5a077c7b4e8ca8a68d6a0377abf0aa2473f97b37779431062dad50ef5fd21cf1"
          "7c0276a293ee5b3f5a130fc5f9b217585cae23e",
          ProofId::fromHex("3fdcb56110cfe2f394689be3dd28dedee674f79a567c8391dbd9"
                           "3900c9845ca8"),
          444638638, ProofValidationResult::INVALID_SIGNATURE},
         {"Changing expiration affect ProofId",
          "d97587e6c882615797011ec8f9a7b1c64104e556ba887297fd6a655bc2579d26814e8"
          "54c902448ec3ce3c6fe965e3420aa3f0e9611d3c0b8a73b6329741e2e726fd17f5e8a"
          "bd546a614b0e05433528b195870169a79ff23e1d58c64afad42ad81cffe53967e16be"
          "b692fc5776bb442c79c5d91de00cf21804712806594010038e168a34104d9d84ebf65"
          "22cf24c6fd4addedd068632a4db06c3cd6e40031c72d416e9eefbd90037383d8da9e9"
          "213a4818a02f108ac1656141ecfbfdde0aeb8620eb210c08b2ce587d9fec0799f9725"
          "5d2bc5a077c7b4e8ca8a68d6a0377abf0aa2473f97b37779431062dad50ef5fd21cf1"
          "7c0276a293ee5b3f5a130fc5f9b217585cae23e",
          ProofId::fromHex("a9ffbb2b37526e05a1f72b43314f872c381281ce8d3d96a5bf56"
                           "47db057a64dc"),
          444638638, ProofValidationResult::INVALID_SIGNATURE},
         {"Changing the master key affect ProofId",
          "d97587e6c882615796011ec8f9a7b1c64104e556ba897297fd6a655bc2579d26814e8"
          "54c902448ec3ce3c6fe965e3420aa3f0e9611d3c0b8a73b6329741e2e726fd17f5e8a"
          "bd546a614b0e05433528b19587 "
          "0169a79ff23e1d58c64afad42ad81cffe53967e16be"
          "b692fc5776bb442c79c5d91de00cf21804712806594010038e168a34104d9d84ebf65"
          "22cf24c6fd4addedd068632a4db06c3cd6e40031c72d416e9eefbd90037383d8da9e9"
          "213a4818a02f108ac1656141ecfbfdde0aeb8620eb210c08b2ce587d9fec0799f9725"
          "5d2bc5a077c7b4e8ca8a68d6a0377abf0aa2473f97b37779431062dad50ef5fd21cf1"
          "7c0276a293ee5b3f5a130fc5f9b217585cae23e",
          ProofId::fromHex("c237e5436f2d21e4ae990422bfb8ec97df52a9f6db5c20c40f54"
                           "64e590dcda39"),
          444638638, ProofValidationResult::INVALID_SIGNATURE},
         {"Changing the TxId affect the ProofId",
          "d97587e6c882615796011ec8f9a7b1c64104e556ba887297fd6a655bc2579d26814e8"
          "54c902448ec3ce3c6fe965e3420aa3f0e9611d3c0b8a73b6329741e2e726fd17f5e8a"
          "bd546a614b0e05433528b195870179a79ff23e1d58c64afad42ad81cffe53967e16be"
          "b692fc5776bb442c79c5d91de00cf21804712806594010038e168a34104d9d84ebf65"
          "22cf24c6fd4addedd068632a4db06c3cd6e40031c72d416e9eefbd90037383d8da9e9"
          "213a4818a02f108ac1656141ecfbfdde0aeb8620eb210c08b2ce587d9fec0799f9725"
          "5d2bc5a077c7b4e8ca8a68d6a0377abf0aa2473f97b37779431062dad50ef5fd21cf1"
          "7c0276a293ee5b3f5a130fc5f9b217585cae23e",
          ProofId::fromHex("9d372d7580917985824c632c919ce8bf89fc6f45c07ee60b2564"
                           "6aea23390ec6"),
          444638638, ProofValidationResult::INVALID_SIGNATURE},
         {"Changing the outpoint index change the ProofId",
          "d97587e6c882615796011ec8f9a7b1c64104e556ba887297fd6a655bc2579d26814e8"
          "54c902448ec3ce3c6fe965e3420aa3f0e9611d3c0b8a73b6329741e2e726fd17f5e8a"
          "bd546a614b0e05433528b195870169a79ff23e1d58c64afad42ad81cffe53967e16be"
          "b692fc5776bb442c79c5d91df00cf21804712806594010038e168a34104d9d84ebf65"
          "22cf24c6fd4addedd068632a4db06c3cd6e40031c72d416e9eefbd90037383d8da9e9"
          "213a4818a02f108ac1656141ecfbfdde0aeb8620eb210c08b2ce587d9fec0799f9725"
          "5d2bc5a077c7b4e8ca8a68d6a0377abf0aa2473f97b37779431062dad50ef5fd21cf1"
          "7c0276a293ee5b3f5a130fc5f9b217585cae23e",
          ProofId::fromHex("1a98c5f7684508665fbc946c64c9486e3f7c91b2f42d299320c5"
                           "56e68e4028fe"),
          444638638, ProofValidationResult::INVALID_SIGNATURE},
         {"Changing the amount changes the ProofId",
          "d97587e6c882615796011ec8f9a7b1c64104e556ba887297fd6a655bc2579d26814e8"
          "54c902448ec3ce3c6fe965e3420aa3f0e9611d3c0b8a73b6329741e2e726fd17f5e8a"
          "bd546a614b0e05433528b195870169a79ff23e1d58c64afad42ad81cffe53967e16be"
          "b692fc5776bb442c79c5d91de00cf21814712806594010038e168a34104d9d84ebf65"
          "22cf24c6fd4addedd068632a4db06c3cd6e40031c72d416e9eefbd90037383d8da9e9"
          "213a4818a02f108ac1656141ecfbfdde0aeb8620eb210c08b2ce587d9fec0799f9725"
          "5d2bc5a077c7b4e8ca8a68d6a0377abf0aa2473f97b37779431062dad50ef5fd21cf1"
          "7c0276a293ee5b3f5a130fc5f9b217585cae23e",
          ProofId::fromHex("528fa9654e845dfe30ed03966240ab615a8d374d86256e1e4892"
                           "83eb0a0be44b"),
          444638638, ProofValidationResult::INVALID_SIGNATURE},
         {"Changing the height changes the ProofId",
          "d97587e6c882615796011ec8f9a7b1c64104e556ba887297fd6a655bc2579d26814e8"
          "54c902448ec3ce3c6fe965e3420aa3f0e9611d3c0b8a73b6329741e2e726fd17f5e8a"
          "bd546a614b0e05433528b195870169a79ff23e1d58c64afad42ad81cffe53967e16be"
          "b692fc5776bb442c79c5d91de00cf21804712806594010028e168a34104d9d84ebf65"
          "22cf24c6fd4addedd068632a4db06c3cd6e40031c72d416e9eefbd90037383d8da9e9"
          "213a4818a02f108ac1656141ecfbfdde0aeb8620eb210c08b2ce587d9fec0799f9725"
          "5d2bc5a077c7b4e8ca8a68d6a0377abf0aa2473f97b37779431062dad50ef5fd21cf1"
          "7c0276a293ee5b3f5a130fc5f9b217585cae23e",
          ProofId::fromHex("a932294f46f106b2b38e57a4b1e4b5849730aba2124662f680a6"
                           "1c8cc429adb0"),
          444638638, ProofValidationResult::INVALID_SIGNATURE},
         {"Changing the pubkey changes the ProofId",
          "d97587e6c882615796011ec8f9a7b1c64104e556ba887297fd6a655bc2579d26814e8"
          "54c902448ec3ce3c6fe965e3420aa3f0e9611d3c0b8a73b6329741e2e726fd17f5e8a"
          "bd546a614b0e05433528b195870169a79ff23e1d58c64afad42ad81cffe53967e16be"
          "b692fc5776bb442c79c5d91de00cf21804712806594010038e168a34104d8d84ebf65"
          "22cf24c6fd4addedd068632a4db06c3cd6e40031c72d416e9eefbd90037383d8da9e9"
          "213a4818a02f108ac1656141ecfbfdde0aeb8620eb210c08b2ce587d9fec0799f9725"
          "5d2bc5a077c7b4e8ca8a68d6a0377abf0aa2473f97b37779431062dad50ef5fd21cf1"
          "7c0276a293ee5b3f5a130fc5f9b217585cae23e",
          ProofId::fromHex("336c9a502b22ba2edcd78298c1ce6cc5e8b5e94cdc60b1047d1f"
                           "96810d5d17a3"),
          444638638, ProofValidationResult::INVALID_SIGNATURE},
         {"Changing the signatue does NOT change the ProofId",
          "d97587e6c882615796011ec8f9a7b1c64104e556ba887297fd6a655bc2579d26814e8"
          "54c902448ec3ce3c6fe965e3420aa3f0e9611d3c0b8a73b6329741e2e726fd17f5e8a"
          "bd546a614b0e05433528b195870169a79ff23e1d58c64afad42ad81cffe53967e16be"
          "b692fc5776bb442c79c5d91de00cf21804712806594010038e168a34104d9d84ebf65"
          "22cf24c6fd4addedd068632a4db06c3cd6e40031c72d416e9eefbd90037383d8da9e9"
          "213a4818a02f108ac1656141ecfbfdde0aeb8620eb210c08b2ce587d9fec0799f9725"
          "5d2bc5a077c7b4e8ca8a68d6a0377abf0aa2473f97b37779431062dad50ef5fd21cf1"
          "7c0276a293ee5b3f5a130fc5f9b217585cae23f",
          ProofId::fromHex("17717dbf1cee175925be12321bb04eda7bc861a28b04d764c2d5"
                           "5eabf01cabd0"),
          444638638, ProofValidationResult::INVALID_SIGNATURE},
         {"1 utxo staked but zero coins",
          "a6d66db9fe9378fdd37a0ad2c01c2acd2103648144bb6a0c1d09b0f04d0df6d55f914"
          "fd81efc65f23a718b68b7c9e42bd5430145a4d07798547464daa53acefb7c97c0c415"
          "ed8e81e549ff56a0ef6f847fcc9ca855b3620000000000000000e707d7274104fb662"
          "6e21dbd1cc9feeecdefc9213fdce2b51ac4bb44e1f8dc6f14c2052f5dd7bfaeb2267a"
          "97ca2bec6e0dd4acf50a66204bde1ebb5d6c551684cff2f939920f7fbb2efd860d6d5"
          "926bf425eb47b78bf6979cdcd67eb705e2c9a4d45a0930ba25463178a3fb99cb28c8b"
          "77d8fcf68c54ebfadf08b9a446c251a0088301c50d53",
          ProofId::fromHex("32c852db61880e9e2d4de3edba2daf3f5449e00bf1bc5b18595f"
                           "80113d5b0722"),
          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_AUTO_TEST_CASE(verify) {
     CCoinsView coinsDummy;
     CCoinsViewCache coins(&coinsDummy);
 
     CKey key;
     key.MakeNewKey(true);
     const CPubKey pubkey = key.GetPubKey();
 
-    const Amount value = 12345 * SATOSHI;
+    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
     {
         CKey altkey;
         altkey.MakeNewKey(true);
         runCheck(ProofValidationResult::DESTINATION_MISMATCH, pkh_outpoint,
                  value, height, false, altkey);
     }
 
     // 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();
 
         ProofValidationState state;
         BOOST_CHECK(!p.verify(state, coins));
         BOOST_CHECK(state.GetResult() ==
                     ProofValidationResult::DUPLICATE_STAKE);
     }
 }
 
 BOOST_AUTO_TEST_SUITE_END()
diff --git a/src/avalanche/test/util.cpp b/src/avalanche/test/util.cpp
index c717edc19..8555e8760 100644
--- a/src/avalanche/test/util.cpp
+++ b/src/avalanche/test/util.cpp
@@ -1,40 +1,49 @@
 // 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) {
     CKey key;
     key.MakeNewKey(true);
 
     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;
+}
+
 } // namespace avalanche
diff --git a/src/avalanche/test/util.h b/src/avalanche/test/util.h
index 0bf0e927b..723caa6ef 100644
--- a/src/avalanche/test/util.h
+++ b/src/avalanche/test/util.h
@@ -1,19 +1,23 @@
 // 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 <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);
+
 } // 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 5ecb949fc..550e6335e 100644
--- a/test/functional/abc_rpc_avalancheproof.py
+++ b/test/functional/abc_rpc_avalancheproof.py
@@ -1,250 +1,262 @@
 #!/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."""
+from decimal import Decimal
 
 from test_framework.avatools import (
     create_coinbase_stakes,
     create_stakes,
 )
 from test_framework.key import ECKey, bytes_to_wif
 from test_framework.messages import AvalancheDelegation
 from test_framework.mininode import P2PInterface
 from test_framework.test_framework import BitcoinTestFramework
 from test_framework.test_node import ErrorMatch
 from test_framework.util import (
     append_config,
     wait_until,
     assert_raises_rpc_error,
 )
 
 AVALANCHE_MAX_PROOF_STAKES = 1000
 
+PROOF_DUST_THRESHOLD = 1.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 = 1
         self.extra_args = [['-enableavalanche=1', '-avacooldown=0'], ]
         self.supports_cli = False
         self.rpc_timeout = 120
 
     def run_test(self):
         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
         proof = node.buildavalancheproof(
             proof_sequence, proof_expiration, proof_master,
             create_coinbase_stakes(node, [blockhashes[0]], addrkey0.key))
 
         # Restart the node, making sure it is initially in IBD mode
         minchainwork = int(node.getblockchaininfo()["chainwork"], 16) + 1
         self.restart_node(0, self.extra_args[0] + [
             "-avaproof={}".format(proof),
             "-avamasterkey=cND2ZvtabDbJ1gucx9GWH6XT9kgTAqfb6cotPt5Q5CyxVDhid2EN",
             "-minimumchainwork=0x{:x}".format(minchainwork),
         ])
 
         self.log.info(
             "The proof verification should be delayed until IBD is complete")
         assert node.getblockchaininfo()["initialblockdownload"] is True
         # Our proof cannot be verified during IBD, so we should have no peer
         assert not node.getavalanchepeerinfo()
         # Mining a few more blocks should cause us to leave IBD
         node.generate(2)
         # Our proof is now verified and our node is added as a peer
         assert node.getblockchaininfo()["initialblockdownload"] is False
         wait_until(lambda: len(node.getavalanchepeerinfo()) == 1, timeout=5)
 
         if self.is_wallet_compiled():
             self.log.info(
                 "A proof using the maximum number of stakes is accepted...")
 
             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)
             peerid1 = add_interface_node(node)
             assert node.addavalanchenode(peerid1, proof_master, good_proof)
 
             self.log.info(
                 "A proof using too many stakes should be rejected...")
             too_many_utxos = node.buildavalancheproof(
                 proof_sequence, proof_expiration,
                 proof_master, too_many_stakes)
             peerid2 = add_interface_node(node)
             assert not node.addavalanchenode(
                 peerid2, proof_master, too_many_utxos)
 
         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(
                 proof,
                 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, [])
         assert_raises_rpc_error(-8, "The proof is invalid",
                                 node.delegateavalancheproof,
                                 no_stake,
                                 bytes_to_wif(privkey.get_bytes()),
                                 random_pubkey,
                                 )
 
         # Invalid privkey
         assert_raises_rpc_error(-5, "The private key is invalid",
                                 node.delegateavalancheproof,
                                 proof,
                                 bytes_to_wif(bytes(32)),
                                 random_pubkey,
                                 )
 
         # Invalid delegation
         bad_dg = AvalancheDelegation()
         assert_raises_rpc_error(-8, "The supplied delegation is not valid",
                                 node.delegateavalancheproof,
                                 proof,
                                 bytes_to_wif(privkey.get_bytes()),
                                 random_pubkey,
                                 bad_dg.serialize().hex(),
                                 )
 
         # Wrong privkey, does not match the proof
         assert_raises_rpc_error(-8, "The private key does not match the proof or the delegation",
                                 node.delegateavalancheproof,
                                 proof,
                                 bytes_to_wif(random_privkey.get_bytes()),
                                 random_pubkey,
                                 )
 
         # Wrong privkey, match the proof but does not match the delegation
         assert_raises_rpc_error(-8, "The private key does not match the proof or the delegation",
                                 node.delegateavalancheproof,
                                 proof,
                                 bytes_to_wif(privkey.get_bytes()),
                                 random_pubkey,
                                 delegation,
                                 )
 
         # Test invalid proofs
         self.log.info("Bad proof should be rejected at startup")
         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))
 
         bad_sig = ("0b000000000000000c0000000000000021030b4c866585dd868a9d62348"
                    "a9cd008d6a312937048fff31670e7e920cfc7a7440105c5f72f5d6da3085"
                    "583e75ee79340eb4eff208c89988e7ed0efb30b87298fa30000000000f20"
                    "52a0100000003000000210227d85ba011276cf25b51df6a188b75e604b3"
                    "8770a462b2d0e9fb2fc839ef5d3faf07f001dd38e9b4a43d07d5d449cc0"
                    "f7d2888d96b82962b3ce516d1083c0e031773487fc3c4f2e38acd1db974"
                    "1321b91a79b82d1c2cfd47793261e4ba003cf5")
 
         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,
             )
 
 
 if __name__ == '__main__':
     AvalancheProofTest().main()