diff --git a/src/wallet/scriptpubkeyman.h b/src/wallet/scriptpubkeyman.h
--- a/src/wallet/scriptpubkeyman.h
+++ b/src/wallet/scriptpubkeyman.h
@@ -5,8 +5,10 @@
 #ifndef BITCOIN_WALLET_SCRIPTPUBKEYMAN_H
 #define BITCOIN_WALLET_SCRIPTPUBKEYMAN_H
 
+#include <psbt.h>
 #include <script/signingprovider.h>
 #include <script/standard.h>
+#include <util/error.h>
 #include <wallet/crypter.h>
 #include <wallet/ismine.h>
 #include <wallet/walletdb.h>
@@ -263,6 +265,16 @@
                     std::map<int, std::string> &input_errors) const {
         return false;
     }
+    /**
+     * Adds script and derivation path information to a PSBT, and optionally
+     * signs it.
+     */
+    virtual TransactionError
+    FillPSBT(PartiallySignedTransaction &psbt,
+             SigHashType sighash_type = SigHashType().withForkId(),
+             bool sign = true, bool bip32derivs = false) const {
+        return TransactionError::INVALID_PSBT;
+    }
 
     virtual uint256 GetID() const { return uint256(); }
 
@@ -435,6 +447,10 @@
     SignTransaction(CMutableTransaction &tx,
                     const std::map<COutPoint, Coin> &coins, SigHashType sighash,
                     std::map<int, std::string> &input_errors) const override;
+    TransactionError
+    FillPSBT(PartiallySignedTransaction &psbt,
+             SigHashType sighash_type = SigHashType().withForkId(),
+             bool sign = true, bool bip32derivs = false) const override;
 
     uint256 GetID() const override;
 
diff --git a/src/wallet/scriptpubkeyman.cpp b/src/wallet/scriptpubkeyman.cpp
--- a/src/wallet/scriptpubkeyman.cpp
+++ b/src/wallet/scriptpubkeyman.cpp
@@ -465,6 +465,49 @@
     return ::SignTransaction(tx, this, coins, sighash, input_errors);
 }
 
+TransactionError
+LegacyScriptPubKeyMan::FillPSBT(PartiallySignedTransaction &psbtx,
+                                SigHashType sighash_type, bool sign,
+                                bool bip32derivs) const {
+    for (size_t i = 0; i < psbtx.tx->vin.size(); ++i) {
+        PSBTInput &input = psbtx.inputs.at(i);
+
+        if (PSBTInputSigned(input)) {
+            continue;
+        }
+
+        // Verify input looks sane. This will check that we have at most one
+        // uxto, witness or non-witness.
+        if (!input.IsSane()) {
+            return TransactionError::INVALID_PSBT;
+        }
+
+        // Get the Sighash type
+        if (sign && input.sighash_type.getRawSigHashType() > 0 &&
+            input.sighash_type != sighash_type) {
+            return TransactionError::SIGHASH_MISMATCH;
+        }
+
+        if (input.utxo.IsNull()) {
+            // There's no UTXO so we can just skip this now
+            continue;
+        }
+        SignatureData sigdata;
+        input.FillSignatureData(sigdata);
+        SignPSBTInput(HidingSigningProvider(this, !sign, !bip32derivs), psbtx,
+                      i, sighash_type);
+    }
+
+    // Fill in the bip32 keypaths and redeemscripts for the outputs so that
+    // hardware wallets can identify change
+    for (size_t i = 0; i < psbtx.tx->vout.size(); ++i) {
+        UpdatePSBTOutput(HidingSigningProvider(this, true, !bip32derivs), psbtx,
+                         i);
+    }
+
+    return TransactionError::OK;
+}
+
 const CKeyMetadata *
 LegacyScriptPubKeyMan::GetMetadata(const CTxDestination &dest) const {
     LOCK(cs_KeyStore);
diff --git a/src/wallet/wallet.cpp b/src/wallet/wallet.cpp
--- a/src/wallet/wallet.cpp
+++ b/src/wallet/wallet.cpp
@@ -2787,7 +2787,6 @@
                                    bool sign, bool bip32derivs) const {
     LOCK(cs_wallet);
     // Get all of the previous transactions
-    complete = true;
     for (size_t i = 0; i < psbtx.tx->vin.size(); ++i) {
         const CTxIn &txin = psbtx.tx->vin[i];
         PSBTInput &input = psbtx.inputs.at(i);
@@ -2812,49 +2811,62 @@
                 input.utxo = utxo;
             }
         }
+    }
+
+    // Fill in information from ScriptPubKeyMans
+    // Because each ScriptPubKeyMan may be able to fill more than one input, we
+    // need to keep track of each ScriptPubKeyMan that has filled this psbt.
+    // Each iteration, we may fill more inputs than the input that is specified
+    // in that iteration. We assume that each input is filled by only one
+    // ScriptPubKeyMan
+    std::set<uint256> visited_spk_mans;
+    for (size_t i = 0; i < psbtx.tx->vin.size(); ++i) {
+        PSBTInput &input = psbtx.inputs.at(i);
 
-        // Get the Sighash type
-        if (sign && input.sighash_type.getRawSigHashType() > 0 &&
-            input.sighash_type != sighash_type) {
-            return TransactionError::SIGHASH_MISMATCH;
+        if (PSBTInputSigned(input)) {
+            continue;
         }
 
-        // Get the scriptPubKey to know which SigningProvider to use
+        // Get the scriptPubKey to know which ScriptPubKeyMan to use
         CScript script;
         if (!input.utxo.IsNull()) {
             script = input.utxo.scriptPubKey;
         } else {
             // There's no UTXO so we can just skip this now
-            complete = false;
             continue;
         }
         SignatureData sigdata;
         input.FillSignatureData(sigdata);
-        std::unique_ptr<SigningProvider> provider =
-            GetSigningProvider(script, sigdata);
-        if (!provider) {
-            complete = false;
+        std::set<ScriptPubKeyMan *> spk_mans =
+            GetScriptPubKeyMans(script, sigdata);
+        if (spk_mans.size() == 0) {
             continue;
         }
 
-        complete &= SignPSBTInput(
-            HidingSigningProvider(provider.get(), !sign, !bip32derivs), psbtx,
-            i, sighash_type);
-    }
+        for (auto &spk_man : spk_mans) {
+            // If we've already been signed by this spk_man, skip it
+            if (visited_spk_mans.count(spk_man->GetID()) > 0) {
+                continue;
+            }
+
+            // Fill in the information from the spk_man
+            TransactionError res =
+                spk_man->FillPSBT(psbtx, sighash_type, sign, bip32derivs);
+            if (res != TransactionError::OK) {
+                return res;
+            }
 
-    // Fill in the bip32 keypaths and redeemscripts for the outputs so that
-    // hardware wallets can identify change
-    for (size_t i = 0; i < psbtx.tx->vout.size(); ++i) {
-        const CTxOut &out = psbtx.tx->vout.at(i);
-        std::unique_ptr<SigningProvider> provider =
-            GetSigningProvider(out.scriptPubKey);
-        if (provider) {
-            UpdatePSBTOutput(
-                HidingSigningProvider(provider.get(), true, !bip32derivs),
-                psbtx, i);
+            // Add this spk_man to visited_spk_mans so we can skip it later
+            visited_spk_mans.insert(spk_man->GetID());
         }
     }
 
+    // Complete if every input is now signed
+    complete = true;
+    for (const auto &input : psbtx.inputs) {
+        complete &= PSBTInputSigned(input);
+    }
+
     return TransactionError::OK;
 }