diff --git a/src/avalanche/proof.cpp b/src/avalanche/proof.cpp
index c3bece84d..c0042f44e 100644
--- a/src/avalanche/proof.cpp
+++ b/src/avalanche/proof.cpp
@@ -1,176 +1,189 @@
 // 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 <streams.h>
 #include <util/strencodings.h>
 
 #include <tinyformat.h>
 
 #include <unordered_set>
 
 namespace avalanche {
 
+void Stake::computeStakeId() {
+    CHashWriter ss(SER_GETHASH, 0);
+    ss << *this;
+    stakeid = StakeId(ss.GetHash());
+}
+
 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);
 }
 
 bool Proof::FromHex(Proof &proof, const std::string &hexProof,
                     bilingual_str &errorOut) {
     if (!IsHex(hexProof)) {
         errorOut = _("Proof must be an hexadecimal string.");
         return false;
     }
 
     CDataStream ss(ParseHex(hexProof), SER_NETWORK, PROTOCOL_VERSION);
 
     try {
         ss >> proof;
     } catch (std::exception &e) {
         errorOut = strprintf(_("Proof has invalid format: %s"), e.what());
         return false;
     }
 
     return true;
 }
 
 void Proof::computeProofId() {
     CHashWriter ss(SER_GETHASH, 0);
     ss << sequence;
     ss << expirationTime;
 
     WriteCompactSize(ss, stakes.size());
     for (const SignedStake &s : stakes) {
         ss << s.getStake();
     }
 
     limitedProofId = LimitedProofId(ss.GetHash());
     proofid = limitedProofId.computeProofId(master);
 }
 
 uint32_t Proof::getScore() const {
     Amount total = Amount::zero();
     for (const SignedStake &s : stakes) {
         total += s.getStake().getAmount();
     }
 
     return uint32_t((100 * total) / COIN);
 }
 
 bool Proof::verify(ProofValidationState &state) const {
     if (stakes.empty()) {
         return state.Invalid(ProofValidationResult::NO_STAKE, "no-stake");
     }
 
     if (stakes.size() > AVALANCHE_MAX_PROOF_STAKES) {
         return state.Invalid(
             ProofValidationResult::TOO_MANY_UTXOS, "too-many-utxos",
             strprintf("%u > %u", stakes.size(), AVALANCHE_MAX_PROOF_STAKES));
     }
 
+    StakeId prevId = uint256::ZERO;
     std::unordered_set<COutPoint, SaltedOutpointHasher> utxos;
     for (const SignedStake &ss : stakes) {
         const Stake &s = ss.getStake();
         if (s.getAmount() < PROOF_DUST_THRESHOLD) {
             return state.Invalid(ProofValidationResult::DUST_THRESOLD,
                                  "amount-below-dust-threshold",
                                  strprintf("%s < %s", s.getAmount().ToString(),
                                            PROOF_DUST_THRESHOLD.ToString()));
         }
 
+        if (s.getId() < prevId) {
+            return state.Invalid(ProofValidationResult::WRONG_STAKE_ORDERING,
+                                 "wrong-stake-ordering");
+        }
+        prevId = s.getId();
+
         if (!utxos.insert(s.getUTXO()).second) {
             return state.Invalid(ProofValidationResult::DUPLICATE_STAKE,
                                  "duplicated-stake");
         }
 
         if (!ss.verify(proofid)) {
             return state.Invalid(ProofValidationResult::INVALID_SIGNATURE,
                                  "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,
                                  "utxo-missing-or-spent");
         }
 
         if (s.isCoinbase() != coin.IsCoinBase()) {
             return state.Invalid(
                 ProofValidationResult::COINBASE_MISMATCH, "coinbase-mismatch",
                 strprintf("expected %s, found %s",
                           s.isCoinbase() ? "true" : "false",
                           coin.IsCoinBase() ? "true" : "false"));
         }
 
         if (s.getHeight() != coin.GetHeight()) {
             return state.Invalid(ProofValidationResult::HEIGHT_MISMATCH,
                                  "height-mismatch",
                                  strprintf("expected %u, found %u",
                                            s.getHeight(), coin.GetHeight()));
         }
 
         const CTxOut &out = coin.GetTxOut();
         if (s.getAmount() != out.nValue) {
             // Wrong amount.
             return state.Invalid(
                 ProofValidationResult::AMOUNT_MISMATCH, "amount-mismatch",
                 strprintf("expected %s, found %s", s.getAmount().ToString(),
                           out.nValue.ToString()));
         }
 
         CTxDestination dest;
         if (!ExtractDestination(out.scriptPubKey, dest)) {
             // Can't extract destination.
             return state.Invalid(
                 ProofValidationResult::NON_STANDARD_DESTINATION,
                 "non-standard-destination");
         }
 
         PKHash *pkhash = boost::get<PKHash>(&dest);
         if (!pkhash) {
             // Only PKHash are supported.
             return state.Invalid(
                 ProofValidationResult::DESTINATION_NOT_SUPPORTED,
                 "destination-type-not-supported");
         }
 
         const CPubKey &pubkey = s.getPubkey();
         if (*pkhash != PKHash(pubkey)) {
             // Wrong pubkey.
             return state.Invalid(ProofValidationResult::DESTINATION_MISMATCH,
                                  "destination-mismatch");
         }
     }
 
     return true;
 }
 
 } // namespace avalanche
diff --git a/src/avalanche/proof.h b/src/avalanche/proof.h
index 2441d6b32..3660201bd 100644
--- a/src/avalanche/proof.h
+++ b/src/avalanche/proof.h
@@ -1,120 +1,130 @@
 // 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 <util/translation.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;
 
+using StakeId = uint256;
+
 class Stake {
     COutPoint utxo;
 
     Amount amount;
     uint32_t height;
     CPubKey pubkey;
 
+    StakeId stakeid;
+    void computeStakeId();
+
 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_)) {}
+          pubkey(std::move(pubkey_)) {
+        computeStakeId();
+    }
 
     SERIALIZE_METHODS(Stake, obj) {
         READWRITE(obj.utxo, obj.amount, obj.height, obj.pubkey);
+        SER_READ(obj, obj.computeStakeId());
     }
 
     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;
+
+    const StakeId &getId() const { return stakeid; }
 };
 
 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;
 
     LimitedProofId limitedProofId;
     ProofId proofid;
     void computeProofId();
 
 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_)) {
         computeProofId();
     }
 
     SERIALIZE_METHODS(Proof, obj) {
         READWRITE(obj.sequence, obj.expirationTime, obj.master, obj.stakes);
         SER_READ(obj, obj.computeProofId());
     }
 
     static bool FromHex(Proof &proof, const std::string &hexProof,
                         bilingual_str &errorOut);
 
     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; }
     const LimitedProofId &getLimitedId() const { return limitedProofId; }
     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/proofbuilder.cpp b/src/avalanche/proofbuilder.cpp
index f848ffd70..9227ab16d 100644
--- a/src/avalanche/proofbuilder.cpp
+++ b/src/avalanche/proofbuilder.cpp
@@ -1,66 +1,73 @@
 // 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;
 }
 
 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));
     }
 
     stakes.clear();
     return Proof(sequence, expirationTime, std::move(master),
                  std::move(signedStakes));
 }
 
-ProofId ProofBuilder::getProofId() const {
+ProofId ProofBuilder::getProofId() {
     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 fc500cc72..777fe4454 100644
--- a/src/avalanche/proofbuilder.h
+++ b/src/avalanche/proofbuilder.h
@@ -1,48 +1,52 @@
 // 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;
 
 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() const;
+    ProofId getProofId();
+
+    friend struct TestProofBuilder;
 };
 
 } // namespace avalanche
 
 #endif // BITCOIN_AVALANCHE_PROOFBUILDER_H
diff --git a/src/avalanche/test/proof_tests.cpp b/src/avalanche/test/proof_tests.cpp
index 638ab4e57..cf091200c 100644
--- a/src/avalanche/test/proof_tests.cpp
+++ b/src/avalanche/test/proof_tests.cpp
@@ -1,447 +1,495 @@
 // 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",
-         "c964aa6fde575e4ce8404581c7be874e21023beefdde700a6bc02036335b4df141c8b"
-         "c67bb05a971f5ac2745fd683797dde30305d427b706705a5d4b6a368a231d6db62aba"
-         "cf8c29bc32b61e7f65a0a6976aa8b86b687bc0260e821e4f0200b9d3bf6d2102449fb"
-         "5237efe8f647d32e8b64f06c22d1d40368eaca2a71ffc6a13ecc8bce68052365271b6"
-         "c71189f5cd7e3b694b77b579080f0b35bae567b96590ab6aa3019b018ff9f061f52f1"
-         "426bdb195d4b6d4dff5114cee90e33dabf0c588ebadf7774418f54247f6390791706a"
-         "f36fac782302479898b5273f9e51a92cb1fb5af43deeb6c8c269403d30ffcb3803001"
-         "34398c42103e49f9df52de2dea81cf7838b82521b69f2ea360f1c4eed9e6c89b7d0f9"
-         "e645efa08e97ea0c60e1f0a064fbf08989c084707082727e85dcb9f79bb503f76ee6c"
-         "8dad42a07ef15c89b3750a5631d604b21fafff0f4de354ade95c2f28160ae549af0d4"
-         "ce48c4ca9d0714b1fa51920270f8575e0af610f07b4e602a018ecdbb649b64fff614c"
-         "0026e9fc8e0030092533d422103aac52f4cfca700e7e9824298e0184755112e32f359"
-         "c832f5f6ad2ef62a2c024af812d6d7f2ecc6223a774e19bce1fb20d94d6b01ea69363"
-         "8f55c74fdaa5358fa9239d03e4caf3d817e8f748ccad55a27b9d365db06ad5a0b779a"
-         "c385f3dc8710",
-         ProofId::fromHex("39488854a79a87a37a5042f3934983d116337f0a38cfa0c78712"
-                          "26ba8edf6a15"),
-         2648393347, ProofValidationResult::NONE},
+         "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();
 
         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 57813e725..6dbfe8697 100644
--- a/src/avalanche/test/util.cpp
+++ b/src/avalanche/test/util.cpp
@@ -1,48 +1,87 @@
 // 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;
+    }
+
+    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());
+
+    for (auto &s : pb.stakes) {
+        signedStakes.push_back(s.sign(proofid));
+    }
+
+    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 723caa6ef..ec602ba19 100644
--- a/src/avalanche/test/util.h
+++ b/src/avalanche/test/util.h
@@ -1,23 +1,29 @@
 // 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);
+};
+
 } // namespace avalanche
 
 #endif // BITCOIN_AVALANCHE_TEST_UTIL_H
diff --git a/src/avalanche/validation.h b/src/avalanche/validation.h
index 7aa92507a..c6547ff2a 100644
--- a/src/avalanche/validation.h
+++ b/src/avalanche/validation.h
@@ -1,41 +1,42 @@
 // 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_VALIDATION_H
 #define BITCOIN_AVALANCHE_VALIDATION_H
 
 #include <consensus/validation.h>
 
 namespace avalanche {
 
 enum class ProofValidationResult {
     NONE = 0,
     NO_STAKE,
     DUST_THRESOLD,
     DUPLICATE_STAKE,
+    WRONG_STAKE_ORDERING,
     INVALID_SIGNATURE,
     TOO_MANY_UTXOS,
 
     // UTXO based errors.
     MISSING_UTXO,
     COINBASE_MISMATCH,
     HEIGHT_MISMATCH,
     AMOUNT_MISMATCH,
     NON_STANDARD_DESTINATION,
     DESTINATION_NOT_SUPPORTED,
     DESTINATION_MISMATCH,
 };
 
 class ProofValidationState : public ValidationState<ProofValidationResult> {};
 
 enum class DelegationResult {
     NONE = 0,
     INVALID_SIGNATURE,
 };
 
 class DelegationState : public ValidationState<DelegationResult> {};
 
 } // namespace avalanche
 
 #endif // BITCOIN_AVALANCHE_VALIDATION_H
diff --git a/test/functional/abc_rpc_avalancheproof.py b/test/functional/abc_rpc_avalancheproof.py
index 9fef5edc3..c179dcb4e 100644
--- a/test/functional/abc_rpc_avalancheproof.py
+++ b/test/functional/abc_rpc_avalancheproof.py
@@ -1,449 +1,469 @@
 #!/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,
             }]
         )
 
         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()