diff --git a/src/wallet/fees.h b/src/wallet/fees.h
--- a/src/wallet/fees.h
+++ b/src/wallet/fees.h
@@ -8,6 +8,7 @@
 #define BITCOIN_WALLET_FEES_H
 
 #include <amount.h>
+#include <feerate.h>
 
 class CCoinControl;
 class CTxMemPool;
@@ -25,4 +26,17 @@
 Amount GetMinimumFee(unsigned int nTxBytes, const CCoinControl &coinControl,
                      const CTxMemPool &pool);
 
+/**
+ * Return the minimum required feerate taking into account the
+ * floating relay feerate and user set minimum transaction feerate
+ */
+CFeeRate GetRequiredFeeRate();
+
+/**
+ * Estimate the minimum fee rate considering user set parameters
+ * and the required fee
+ */
+CFeeRate GetMinimumFeeRate(const CCoinControl &coin_control,
+                           const CTxMemPool &pool);
+
 #endif // BITCOIN_WALLET_FEES_H
diff --git a/src/wallet/fees.cpp b/src/wallet/fees.cpp
--- a/src/wallet/fees.cpp
+++ b/src/wallet/fees.cpp
@@ -14,27 +14,13 @@
 #include <wallet/wallet.h>
 
 Amount GetRequiredFee(unsigned int nTxBytes) {
-    return GetConfig().GetMinFeePerKB().GetFee(nTxBytes);
+    return GetRequiredFeeRate().GetFeeCeiling(nTxBytes);
 }
 
-Amount GetMinimumFee(unsigned int nTxBytes, const CCoinControl &coinControl,
+Amount GetMinimumFee(unsigned int nTxBytes, const CCoinControl &coin_control,
                      const CTxMemPool &pool) {
-    Amount targetFee = (coinControl.fOverrideFeeRate && coinControl.m_feerate)
-                           ? coinControl.m_feerate->GetFee(nTxBytes)
-                           : payTxFee.GetFeeCeiling(nTxBytes);
-
-    Amount nFeeNeeded = targetFee;
-    if (nFeeNeeded == Amount::zero()) {
-        nFeeNeeded = pool.estimateFee().GetFeeCeiling(nTxBytes);
-        // ... unless we don't have enough mempool data for estimatefee, then
-        // use fallbackFee.
-        if (nFeeNeeded == Amount::zero()) {
-            nFeeNeeded = CWallet::fallbackFee.GetFeeCeiling(nTxBytes);
-        }
-    }
-
-    // Prevent user from paying a fee below minRelayTxFee or minTxFee.
-    nFeeNeeded = std::max(nFeeNeeded, GetRequiredFee(nTxBytes));
+    Amount nFeeNeeded =
+        GetMinimumFeeRate(coin_control, pool).GetFeeCeiling(nTxBytes);
 
     // But always obey the maximum.
     if (nFeeNeeded > maxTxFee) {
@@ -43,3 +29,27 @@
 
     return nFeeNeeded;
 }
+
+CFeeRate GetRequiredFeeRate() {
+    return GetConfig().GetMinFeePerKB();
+}
+
+CFeeRate GetMinimumFeeRate(const CCoinControl &coin_control,
+                           const CTxMemPool &pool) {
+    CFeeRate neededFeeRate =
+        (coin_control.fOverrideFeeRate && coin_control.m_feerate)
+            ? *coin_control.m_feerate
+            : payTxFee;
+
+    if (neededFeeRate == CFeeRate()) {
+        neededFeeRate = pool.estimateFee();
+        // ... unless we don't have enough mempool data for estimatefee, then
+        // use fallbackFee.
+        if (neededFeeRate == CFeeRate()) {
+            neededFeeRate = CWallet::fallbackFee;
+        }
+    }
+
+    // Prevent user from paying a fee below minRelayTxFee or minTxFee.
+    return std::max(neededFeeRate, GetRequiredFeeRate());
+}