diff --git a/src/avalanche/proof.h b/src/avalanche/proof.h
--- a/src/avalanche/proof.h
+++ b/src/avalanche/proof.h
@@ -11,6 +11,7 @@
 #include <primitives/transaction.h>
 #include <pubkey.h>
 #include <serialize.h>
+#include <util/translation.h>
 
 #include <array>
 #include <cstdint>
@@ -96,6 +97,9 @@
         SER_READ(obj, obj.proofid = 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; }
diff --git a/src/avalanche/proof.cpp b/src/avalanche/proof.cpp
--- a/src/avalanche/proof.cpp
+++ b/src/avalanche/proof.cpp
@@ -8,6 +8,10 @@
 #include <coins.h>
 #include <hash.h>
 #include <script/standard.h>
+#include <streams.h>
+#include <util/strencodings.h>
+
+#include <tinyformat.h>
 
 #include <unordered_set>
 
@@ -24,6 +28,25 @@
     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;
+}
+
 ProofId Proof::computeProofId() const {
     CHashWriter ss(SER_GETHASH, 0);
     ss << sequence;
@@ -49,26 +72,33 @@
 
 bool Proof::verify(ProofValidationState &state) const {
     if (stakes.empty()) {
-        return state.Invalid(ProofValidationResult::NO_STAKE);
+        return state.Invalid(ProofValidationResult::NO_STAKE, "no-stake");
     }
 
     if (stakes.size() > AVALANCHE_MAX_PROOF_STAKES) {
-        return state.Invalid(ProofValidationResult::TOO_MANY_UTXOS);
+        return state.Invalid(
+            ProofValidationResult::TOO_MANY_UTXOS, "too-many-utxos",
+            strprintf("%u > %u", stakes.size(), AVALANCHE_MAX_PROOF_STAKES));
     }
 
     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);
+            return state.Invalid(ProofValidationResult::DUST_THRESOLD,
+                                 "amount-below-dust-threshold",
+                                 strprintf("%s < %s", s.getAmount().ToString(),
+                                           PROOF_DUST_THRESHOLD.ToString()));
         }
 
         if (!utxos.insert(s.getUTXO()).second) {
-            return state.Invalid(ProofValidationResult::DUPLICATE_STAKE);
+            return state.Invalid(ProofValidationResult::DUPLICATE_STAKE,
+                                 "duplicated-stake");
         }
 
         if (!ss.verify(proofid)) {
-            return state.Invalid(ProofValidationResult::INVALID_SIGNATURE);
+            return state.Invalid(ProofValidationResult::INVALID_SIGNATURE,
+                                 "invalid-signature");
         }
     }
 
@@ -88,41 +118,55 @@
         Coin coin;
         if (!view.GetCoin(utxo, coin)) {
             // The coins are not in the UTXO set.
-            return state.Invalid(ProofValidationResult::MISSING_UTXO);
+            return state.Invalid(ProofValidationResult::MISSING_UTXO,
+                                 "utxo-missing-or-spent");
         }
 
         if (s.isCoinbase() != coin.IsCoinBase()) {
-            return state.Invalid(ProofValidationResult::COINBASE_MISMATCH);
+            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);
+            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);
+            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);
+                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);
+                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);
+            return state.Invalid(ProofValidationResult::DESTINATION_MISMATCH,
+                                 "destination-mismatch");
         }
     }
 
diff --git a/src/rpc/avalanche.cpp b/src/rpc/avalanche.cpp
--- a/src/rpc/avalanche.cpp
+++ b/src/rpc/avalanche.cpp
@@ -12,6 +12,8 @@
 #include <config.h>
 #include <core_io.h>
 #include <key_io.h>
+#include <node/context.h>
+#include <rpc/blockchain.h>
 #include <rpc/server.h>
 #include <rpc/util.h>
 #include <util/strencodings.h>
@@ -400,6 +402,44 @@
     return ret;
 }
 
+static UniValue verifyavalancheproof(const Config &config,
+                                     const JSONRPCRequest &request) {
+    RPCHelpMan{
+        "verifyavalancheproof",
+        "Verify an avalanche proof is valid and return the error otherwise.\n",
+        {
+            {"proof", RPCArg::Type::STR_HEX, RPCArg::Optional::NO,
+             "Proof to verify."},
+        },
+        RPCResult{RPCResult::Type::BOOL, "success",
+                  "Whether the proof is valid or not."},
+        RPCExamples{HelpExampleRpc("verifyavalancheproof", "\"<proof>\"")},
+    }
+        .Check(request);
+
+    RPCTypeCheck(request.params, {UniValue::VSTR});
+
+    avalanche::Proof proof;
+    bilingual_str error;
+    if (!avalanche::Proof::FromHex(proof, request.params[0].get_str(), error)) {
+        throw JSONRPCError(RPC_INVALID_PARAMETER, error.original);
+    }
+
+    NodeContext &node = EnsureNodeContext(request.context);
+
+    avalanche::ProofValidationState state;
+    {
+        LOCK(cs_main);
+        if (!proof.verify(state,
+                          node.chainman->ActiveChainstate().CoinsTip())) {
+            throw JSONRPCError(RPC_INVALID_PARAMETER,
+                               "The proof is invalid: " + state.ToString());
+        }
+    }
+
+    return true;
+}
+
 void RegisterAvalancheRPCCommands(CRPCTable &t) {
     // clang-format off
     static const CRPCCommand commands[] = {
@@ -410,6 +450,7 @@
         { "avalanche",          "buildavalancheproof",    buildavalancheproof,    {"sequence", "expiration", "master", "stakes"}},
         { "avalanche",          "delegateavalancheproof", delegateavalancheproof, {"proof", "privatekey", "publickey", "delegation"}},
         { "avalanche",          "getavalanchepeerinfo",   getavalanchepeerinfo,   {}},
+        { "avalanche",          "verifyavalancheproof",   verifyavalancheproof,   {"proof"}},
     };
     // clang-format on
 
diff --git a/test/functional/abc_rpc_avalancheproof.py b/test/functional/abc_rpc_avalancheproof.py
--- a/test/functional/abc_rpc_avalancheproof.py
+++ b/test/functional/abc_rpc_avalancheproof.py
@@ -179,7 +179,6 @@
                                 )
 
         # 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"))
@@ -202,6 +201,30 @@
                    "f7d2888d96b82962b3ce516d1083c0e031773487fc3c4f2e38acd1db974"
                    "1321b91a79b82d1c2cfd47793261e4ba003cf5")
 
+        self.log.info("Check the verifyavalancheproof RPC")
+
+        assert_raises_rpc_error(-8, "Proof must be an hexadecimal string",
+                                    node.verifyavalancheproof, "f00")
+        assert_raises_rpc_error(-8, "Proof has invalid format",
+                                    node.verifyavalancheproof, "f00d")
+
+        def check_verifyavalancheproof_failure(proof, message):
+            assert_raises_rpc_error(-8, "The proof is invalid: " + message,
+                                    node.verifyavalancheproof, proof)
+
+        check_verifyavalancheproof_failure(no_stake, "no-stake")
+        check_verifyavalancheproof_failure(dust, "amount-below-dust-threshold")
+        check_verifyavalancheproof_failure(duplicate_stake, "duplicated-stake")
+        check_verifyavalancheproof_failure(bad_sig, "invalid-signature")
+        if self.is_wallet_compiled():
+            check_verifyavalancheproof_failure(
+                too_many_utxos, "too-many-utxos")
+
+        # Good proof
+        assert node.verifyavalancheproof(proof)
+
+        self.log.info("Bad proof should be rejected at startup")
+
         self.stop_node(0)
 
         node.assert_start_raises_init_error(