diff --git a/src/qt/bitcoinunits.cpp b/src/qt/bitcoinunits.cpp
index 917f296e40..0edf00bb75 100644
--- a/src/qt/bitcoinunits.cpp
+++ b/src/qt/bitcoinunits.cpp
@@ -1,220 +1,240 @@
 // Copyright (c) 2011-2016 The Bitcoin Core developers
 // Distributed under the MIT software license, see the accompanying
 // file COPYING or http://www.opensource.org/licenses/mit-license.php.
 
 #include <qt/bitcoinunits.h>
 
 #include <primitives/transaction.h>
 
 #include <QStringList>
 
 BitcoinUnits::BitcoinUnits(QObject *parent)
     : QAbstractListModel(parent), unitlist(availableUnits()) {}
 
 QList<BitcoinUnits::Unit> BitcoinUnits::availableUnits() {
     QList<BitcoinUnits::Unit> unitlist;
     unitlist.append(BCH);
     unitlist.append(mBCH);
     unitlist.append(uBCH);
+    unitlist.append(SAT);
     return unitlist;
 }
 
 bool BitcoinUnits::valid(int unit) {
     switch (unit) {
         case BCH:
         case mBCH:
         case uBCH:
+        case SAT:
             return true;
         default:
             return false;
     }
 }
 
 QString BitcoinUnits::longName(int unit) {
     switch (unit) {
         case BCH:
             return QString("BCH");
         case mBCH:
             return QString("mBCH");
         case uBCH:
             return QString::fromUtf8("μBCH");
+        case SAT:
+            return QString("Satoshi (sat)");
         default:
             return QString("???");
     }
 }
 
 QString BitcoinUnits::shortName(int unit) {
-    return longName(unit);
+    switch (unit) {
+        case SAT:
+            return QString("sat");
+        default:
+            return longName(unit);
+    }
 }
 
 QString BitcoinUnits::description(int unit) {
     switch (unit) {
         case BCH:
             return QString("Bitcoins");
         case mBCH:
             return QString("Milli-Bitcoins (1 / 1" THIN_SP_UTF8 "000)");
         case uBCH:
             return QString("Micro-Bitcoins (1 / 1" THIN_SP_UTF8
                            "000" THIN_SP_UTF8 "000)");
+        case SAT:
+            return QString("Satoshi (sat) (1 / 100" THIN_SP_UTF8
+                           "000" THIN_SP_UTF8 "000)");
         default:
             return QString("???");
     }
 }
 
 qint64 BitcoinUnits::factor(int unit) {
     switch (unit) {
         case BCH:
             return 100000000;
         case mBCH:
             return 100000;
         case uBCH:
             return 100;
+        case SAT:
+            return 1;
         default:
             return 100000000;
     }
 }
 
 int BitcoinUnits::decimals(int unit) {
     switch (unit) {
         case BCH:
             return 8;
         case mBCH:
             return 5;
         case uBCH:
             return 2;
+        case SAT:
+            return 0;
         default:
             return 0;
     }
 }
 
 QString BitcoinUnits::format(int unit, const Amount nIn, bool fPlus,
                              SeparatorStyle separators) {
     // Note: not using straight sprintf here because we do NOT want
     // localized number formatting.
     if (!valid(unit)) {
         // Refuse to format invalid unit
         return QString();
     }
     qint64 n = qint64(nIn / SATOSHI);
     qint64 coin = factor(unit);
     int num_decimals = decimals(unit);
     qint64 n_abs = (n > 0 ? n : -n);
     qint64 quotient = n_abs / coin;
-    qint64 remainder = n_abs % coin;
     QString quotient_str = QString::number(quotient);
-    QString remainder_str =
-        QString::number(remainder).rightJustified(num_decimals, '0');
 
     // Use SI-style thin space separators as these are locale independent and
     // can't be confused with the decimal marker.
     QChar thin_sp(THIN_SP_CP);
     int q_size = quotient_str.size();
     if (separators == separatorAlways ||
         (separators == separatorStandard && q_size > 4)) {
         for (int i = 3; i < q_size; i += 3) {
             quotient_str.insert(q_size - i, thin_sp);
         }
     }
 
     if (n < 0) {
         quotient_str.insert(0, '-');
     } else if (fPlus && n > 0) {
         quotient_str.insert(0, '+');
     }
 
-    return quotient_str + QString(".") + remainder_str;
+    if (num_decimals > 0) {
+        qint64 remainder = n_abs % coin;
+        QString remainder_str =
+            QString::number(remainder).rightJustified(num_decimals, '0');
+        return quotient_str + QString(".") + remainder_str;
+    } else {
+        return quotient_str;
+    }
 }
 
 // NOTE: Using formatWithUnit in an HTML context risks wrapping
 // quantities at the thousands separator. More subtly, it also results
 // in a standard space rather than a thin space, due to a bug in Qt's
 // XML whitespace canonicalisation
 //
 // Please take care to use formatHtmlWithUnit instead, when
 // appropriate.
 
 QString BitcoinUnits::formatWithUnit(int unit, const Amount amount,
                                      bool plussign, SeparatorStyle separators) {
     return format(unit, amount, plussign, separators) + QString(" ") +
            shortName(unit);
 }
 
 QString BitcoinUnits::formatHtmlWithUnit(int unit, const Amount amount,
                                          bool plussign,
                                          SeparatorStyle separators) {
     QString str(formatWithUnit(unit, amount, plussign, separators));
     str.replace(QChar(THIN_SP_CP), QString(THIN_SP_HTML));
     return QString("<span style='white-space: nowrap;'>%1</span>").arg(str);
 }
 
 bool BitcoinUnits::parse(int unit, const QString &value, Amount *val_out) {
     if (!valid(unit) || value.isEmpty()) {
         // Refuse to parse invalid unit or empty string
         return false;
     }
     int num_decimals = decimals(unit);
 
     // Ignore spaces and thin spaces when parsing
     QStringList parts = removeSpaces(value).split(".");
 
     if (parts.size() > 2) {
         // More than one dot
         return false;
     }
     QString whole = parts[0];
     QString decimals;
 
     if (parts.size() > 1) {
         decimals = parts[1];
     }
     if (decimals.size() > num_decimals) {
         // Exceeds max precision
         return false;
     }
     bool ok = false;
     QString str = whole + decimals.leftJustified(num_decimals, '0');
 
     if (str.size() > 18) {
         // Longer numbers will exceed 63 bits
         return false;
     }
     Amount retvalue(int64_t(str.toLongLong(&ok)) * SATOSHI);
     if (val_out) {
         *val_out = retvalue;
     }
     return ok;
 }
 
 QString BitcoinUnits::getAmountColumnTitle(int unit) {
     QString amountTitle = QObject::tr("Amount");
     if (BitcoinUnits::valid(unit)) {
         amountTitle += " (" + BitcoinUnits::shortName(unit) + ")";
     }
     return amountTitle;
 }
 
 int BitcoinUnits::rowCount(const QModelIndex &parent) const {
     Q_UNUSED(parent);
     return unitlist.size();
 }
 
 QVariant BitcoinUnits::data(const QModelIndex &index, int role) const {
     int row = index.row();
     if (row >= 0 && row < unitlist.size()) {
         Unit unit = unitlist.at(row);
         switch (role) {
             case Qt::EditRole:
             case Qt::DisplayRole:
                 return QVariant(longName(unit));
             case Qt::ToolTipRole:
                 return QVariant(description(unit));
             case UnitRole:
                 return QVariant(static_cast<int>(unit));
         }
     }
     return QVariant();
 }
 
 Amount BitcoinUnits::maxMoney() {
     return MAX_MONEY;
 }
diff --git a/src/qt/bitcoinunits.h b/src/qt/bitcoinunits.h
index e29bdf8db8..37b20966fd 100644
--- a/src/qt/bitcoinunits.h
+++ b/src/qt/bitcoinunits.h
@@ -1,128 +1,128 @@
 // Copyright (c) 2011-2016 The Bitcoin Core developers
 // Distributed under the MIT software license, see the accompanying
 // file COPYING or http://www.opensource.org/licenses/mit-license.php.
 
 #ifndef BITCOIN_QT_BITCOINUNITS_H
 #define BITCOIN_QT_BITCOINUNITS_H
 
 #include <amount.h>
 
 #include <QAbstractListModel>
 #include <QString>
 
 // U+2009 THIN SPACE = UTF-8 E2 80 89
 #define REAL_THIN_SP_CP 0x2009
 #define REAL_THIN_SP_UTF8 "\xE2\x80\x89"
 #define REAL_THIN_SP_HTML "&thinsp;"
 
 // U+200A HAIR SPACE = UTF-8 E2 80 8A
 #define HAIR_SP_CP 0x200A
 #define HAIR_SP_UTF8 "\xE2\x80\x8A"
 #define HAIR_SP_HTML "&#8202;"
 
 // U+2006 SIX-PER-EM SPACE = UTF-8 E2 80 86
 #define SIXPEREM_SP_CP 0x2006
 #define SIXPEREM_SP_UTF8 "\xE2\x80\x86"
 #define SIXPEREM_SP_HTML "&#8198;"
 
 // U+2007 FIGURE SPACE = UTF-8 E2 80 87
 #define FIGURE_SP_CP 0x2007
 #define FIGURE_SP_UTF8 "\xE2\x80\x87"
 #define FIGURE_SP_HTML "&#8199;"
 
 // QMessageBox seems to have a bug whereby it doesn't display thin/hair spaces
 // correctly. Workaround is to display a space in a small font. If you change
 // this, please test that it doesn't cause the parent span to start wrapping.
 #define HTML_HACK_SP                                                           \
     "<span style='white-space: nowrap; font-size: 6pt'> </span>"
 
 // Define THIN_SP_* variables to be our preferred type of thin space
 #define THIN_SP_CP REAL_THIN_SP_CP
 #define THIN_SP_UTF8 REAL_THIN_SP_UTF8
 #define THIN_SP_HTML HTML_HACK_SP
 
 /**
  * Bitcoin unit definitions. Encapsulates parsing and formatting and serves as
  * list model for drop-down selection boxes.
  */
 class BitcoinUnits : public QAbstractListModel {
     Q_OBJECT
 
 public:
     explicit BitcoinUnits(QObject *parent);
 
     /**
      * Bitcoin units (Bitcoin Cash unit work the same as Bitoin).
      * @note Source: https://en.bitcoin.it/wiki/Units.
      * Please add only sensible ones.
      */
-    enum Unit { BCH, mBCH, uBCH };
+    enum Unit { BCH, mBCH, uBCH, SAT };
 
     enum SeparatorStyle { separatorNever, separatorStandard, separatorAlways };
 
     //! @name Static API
     //! Unit conversion and formatting
     ///@{
 
     //! Get list of units, for drop-down box
     static QList<Unit> availableUnits();
     //! Is unit ID valid?
     static bool valid(int unit);
     //! Long name
     static QString longName(int unit);
     //! Short name
     static QString shortName(int unit);
     //! Longer description
     static QString description(int unit);
     //! Number of Satoshis (1e-8) per unit
     static qint64 factor(int unit);
     //! Number of decimals left
     static int decimals(int unit);
     //! Format as string
     static QString format(int unit, const Amount amount, bool plussign = false,
                           SeparatorStyle separators = separatorStandard);
     //! Format as string (with unit)
     static QString
     formatWithUnit(int unit, const Amount amount, bool plussign = false,
                    SeparatorStyle separators = separatorStandard);
     //! Format as HTML string (with unit)
     static QString
     formatHtmlWithUnit(int unit, const Amount amount, bool plussign = false,
                        SeparatorStyle separators = separatorStandard);
     //! Parse string to coin amount
     static bool parse(int unit, const QString &value, Amount *val_out);
     //! Gets title for amount column including current display unit if
     //! optionsModel reference available */
     static QString getAmountColumnTitle(int unit);
     ///@}
 
     //! @name AbstractListModel implementation
     //! List model for unit drop-down selection box.
     ///@{
     enum RoleIndex {
         /** Unit identifier */
         UnitRole = Qt::UserRole
     };
     int rowCount(const QModelIndex &parent) const override;
     QVariant data(const QModelIndex &index, int role) const override;
     ///@}
 
     static QString removeSpaces(QString text) {
         text.remove(' ');
         text.remove(QChar(THIN_SP_CP));
 #if (THIN_SP_CP != REAL_THIN_SP_CP)
         text.remove(QChar(REAL_THIN_SP_CP));
 #endif
         return text;
     }
 
     //! Return maximum number of base units (Satoshis)
     static Amount maxMoney();
 
 private:
     QList<BitcoinUnits::Unit> unitlist;
 };
 
 typedef BitcoinUnits::Unit BitcoinUnit;
 
 #endif // BITCOIN_QT_BITCOINUNITS_H