diff --git a/src/qt/sendcoinsentry.cpp b/src/qt/sendcoinsentry.cpp
index 8bbb830944..64882b3772 100644
--- a/src/qt/sendcoinsentry.cpp
+++ b/src/qt/sendcoinsentry.cpp
@@ -1,299 +1,301 @@
 // 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/forms/ui_sendcoinsentry.h>
 #include <qt/sendcoinsentry.h>
 
 #include <config.h>
 #include <qt/addressbookpage.h>
 #include <qt/addresstablemodel.h>
 #include <qt/guiutil.h>
 #include <qt/optionsmodel.h>
 #include <qt/platformstyle.h>
 #include <qt/walletmodel.h>
 
 #include <QApplication>
 #include <QClipboard>
 
 SendCoinsEntry::SendCoinsEntry(const PlatformStyle *_platformStyle,
                                WalletModel *_model, QWidget *parent)
     : QStackedWidget(parent), ui(new Ui::SendCoinsEntry), model(_model),
       platformStyle(_platformStyle) {
     ui->setupUi(this);
 
     ui->addressBookButton->setIcon(
         platformStyle->SingleColorIcon(":/icons/address-book"));
     ui->pasteButton->setIcon(
         platformStyle->SingleColorIcon(":/icons/editpaste"));
     ui->deleteButton->setIcon(platformStyle->SingleColorIcon(":/icons/remove"));
     ui->deleteButton_is->setIcon(
         platformStyle->SingleColorIcon(":/icons/remove"));
     ui->deleteButton_s->setIcon(
         platformStyle->SingleColorIcon(":/icons/remove"));
 
     setCurrentWidget(ui->SendCoins);
 
     if (platformStyle->getUseExtraSpacing()) {
         ui->payToLayout->setSpacing(4);
     }
     ui->addAsLabel->setPlaceholderText(
         tr("Enter a label for this address to add it to your address book"));
 
     // normal bitcoin address field
     GUIUtil::setupAddressWidget(ui->payTo, this);
     // just a label for displaying bitcoin address(es)
     ui->payTo_is->setFont(GUIUtil::fixedPitchFont());
 
     // Connect signals
-    connect(ui->payAmount, SIGNAL(valueChanged()), this,
-            SIGNAL(payAmountChanged()));
-    connect(ui->checkboxSubtractFeeFromAmount, SIGNAL(toggled(bool)), this,
-            SIGNAL(subtractFeeFromAmountChanged()));
-    connect(ui->deleteButton, SIGNAL(clicked()), this, SLOT(deleteClicked()));
-    connect(ui->deleteButton_is, SIGNAL(clicked()), this,
-            SLOT(deleteClicked()));
-    connect(ui->deleteButton_s, SIGNAL(clicked()), this, SLOT(deleteClicked()));
-    connect(ui->useAvailableBalanceButton, SIGNAL(clicked()), this,
-            SLOT(useAvailableBalanceClicked()));
+    connect(ui->payAmount, &BitcoinAmountField::valueChanged, this,
+            &SendCoinsEntry::payAmountChanged);
+    connect(ui->checkboxSubtractFeeFromAmount, &QCheckBox::toggled, this,
+            &SendCoinsEntry::subtractFeeFromAmountChanged);
+    connect(ui->deleteButton, &QPushButton::clicked, this,
+            &SendCoinsEntry::deleteClicked);
+    connect(ui->deleteButton_is, &QPushButton::clicked, this,
+            &SendCoinsEntry::deleteClicked);
+    connect(ui->deleteButton_s, &QPushButton::clicked, this,
+            &SendCoinsEntry::deleteClicked);
+    connect(ui->useAvailableBalanceButton, &QPushButton::clicked, this,
+            &SendCoinsEntry::useAvailableBalanceClicked);
 
     // Set the model properly.
     setModel(model);
 }
 
 SendCoinsEntry::~SendCoinsEntry() {
     delete ui;
 }
 
 void SendCoinsEntry::on_pasteButton_clicked() {
     // Paste text from clipboard into recipient field
     ui->payTo->setText(QApplication::clipboard()->text());
 }
 
 void SendCoinsEntry::on_addressBookButton_clicked() {
     if (!model) {
         return;
     }
     AddressBookPage dlg(platformStyle, AddressBookPage::ForSelection,
                         AddressBookPage::SendingTab, this);
     dlg.setModel(model->getAddressTableModel());
     if (dlg.exec()) {
         ui->payTo->setText(dlg.getReturnValue());
         ui->payAmount->setFocus();
     }
 }
 
 void SendCoinsEntry::on_payTo_textChanged(const QString &address) {
     updateLabel(address);
 }
 
 void SendCoinsEntry::setModel(WalletModel *_model) {
     this->model = _model;
 
     if (_model) {
         ui->messageTextLabel->setToolTip(
             tr("A message that was attached to the %1 URI which will be stored "
                "with the transaction for your reference. Note: This message "
                "will not be sent over the Bitcoin network.")
                 .arg(QString::fromStdString(
                     _model->getChainParams().CashAddrPrefix())));
     }
 
     if (_model && _model->getOptionsModel()) {
-        connect(_model->getOptionsModel(), SIGNAL(displayUnitChanged(int)),
-                this, SLOT(updateDisplayUnit()));
+        connect(_model->getOptionsModel(), &OptionsModel::displayUnitChanged,
+                this, &SendCoinsEntry::updateDisplayUnit);
     }
 
     clear();
 }
 
 void SendCoinsEntry::clear() {
     // clear UI elements for normal payment
     ui->payTo->clear();
     ui->addAsLabel->clear();
     ui->payAmount->clear();
     ui->checkboxSubtractFeeFromAmount->setCheckState(Qt::Unchecked);
     ui->messageTextLabel->clear();
     ui->messageTextLabel->hide();
     ui->messageLabel->hide();
     // clear UI elements for unauthenticated payment request
     ui->payTo_is->clear();
     ui->memoTextLabel_is->clear();
     ui->payAmount_is->clear();
     // clear UI elements for authenticated payment request
     ui->payTo_s->clear();
     ui->memoTextLabel_s->clear();
     ui->payAmount_s->clear();
 
     // update the display unit, to not use the default ("BCH")
     updateDisplayUnit();
 }
 
 void SendCoinsEntry::checkSubtractFeeFromAmount() {
     ui->checkboxSubtractFeeFromAmount->setChecked(true);
 }
 
 void SendCoinsEntry::deleteClicked() {
     Q_EMIT removeEntry(this);
 }
 
 void SendCoinsEntry::useAvailableBalanceClicked() {
     Q_EMIT useAvailableBalance(this);
 }
 
 bool SendCoinsEntry::validate(interfaces::Node &node) {
     if (!model) {
         return false;
     }
 
     // Check input validity
     bool retval = true;
 
     // Skip checks for payment request
     if (recipient.paymentRequest.IsInitialized()) {
         return retval;
     }
 
     if (!model->validateAddress(ui->payTo->text())) {
         ui->payTo->setValid(false);
         retval = false;
     }
 
     if (!ui->payAmount->validate()) {
         retval = false;
     }
 
     // Sending a zero amount is invalid
     if (ui->payAmount->value(0) <= Amount::zero()) {
         ui->payAmount->setValid(false);
         retval = false;
     }
 
     // Reject dust outputs:
     if (retval &&
         GUIUtil::isDust(node, ui->payTo->text(), ui->payAmount->value(),
                         model->getChainParams())) {
         ui->payAmount->setValid(false);
         retval = false;
     }
 
     return retval;
 }
 
 SendCoinsRecipient SendCoinsEntry::getValue() {
     // Payment request
     if (recipient.paymentRequest.IsInitialized()) {
         return recipient;
     }
 
     // Normal payment
     recipient.address = ui->payTo->text();
     recipient.label = ui->addAsLabel->text();
     recipient.amount = ui->payAmount->value();
     recipient.message = ui->messageTextLabel->text();
     recipient.fSubtractFeeFromAmount =
         (ui->checkboxSubtractFeeFromAmount->checkState() == Qt::Checked);
 
     return recipient;
 }
 
 QWidget *SendCoinsEntry::setupTabChain(QWidget *prev) {
     QWidget::setTabOrder(prev, ui->payTo);
     QWidget::setTabOrder(ui->payTo, ui->addAsLabel);
     QWidget *w = ui->payAmount->setupTabChain(ui->addAsLabel);
     QWidget::setTabOrder(w, ui->checkboxSubtractFeeFromAmount);
     QWidget::setTabOrder(ui->checkboxSubtractFeeFromAmount,
                          ui->addressBookButton);
     QWidget::setTabOrder(ui->addressBookButton, ui->pasteButton);
     QWidget::setTabOrder(ui->pasteButton, ui->deleteButton);
     return ui->deleteButton;
 }
 
 void SendCoinsEntry::setValue(const SendCoinsRecipient &value) {
     recipient = value;
 
     // payment request
     if (recipient.paymentRequest.IsInitialized()) {
         // unauthenticated
         if (recipient.authenticatedMerchant.isEmpty()) {
             ui->payTo_is->setText(recipient.address);
             ui->memoTextLabel_is->setText(recipient.message);
             ui->payAmount_is->setValue(recipient.amount);
             ui->payAmount_is->setReadOnly(true);
             setCurrentWidget(ui->SendCoins_UnauthenticatedPaymentRequest);
         }
 
         // authenticated
         else {
             ui->payTo_s->setText(recipient.authenticatedMerchant);
             ui->memoTextLabel_s->setText(recipient.message);
             ui->payAmount_s->setValue(recipient.amount);
             ui->payAmount_s->setReadOnly(true);
             setCurrentWidget(ui->SendCoins_AuthenticatedPaymentRequest);
         }
     }
 
     // normal payment
     else {
         // message
         ui->messageTextLabel->setText(recipient.message);
         ui->messageTextLabel->setVisible(!recipient.message.isEmpty());
         ui->messageLabel->setVisible(!recipient.message.isEmpty());
 
         ui->addAsLabel->clear();
         // this may set a label from addressbook
         ui->payTo->setText(recipient.address);
         // if a label had been set from the addressbook, don't overwrite with an
         // empty label
         if (!recipient.label.isEmpty()) {
             ui->addAsLabel->setText(recipient.label);
         }
         ui->payAmount->setValue(recipient.amount);
     }
 }
 
 void SendCoinsEntry::setAddress(const QString &address) {
     ui->payTo->setText(address);
     ui->payAmount->setFocus();
 }
 
 void SendCoinsEntry::setAmount(const Amount amount) {
     ui->payAmount->setValue(amount);
 }
 
 bool SendCoinsEntry::isClear() {
     return ui->payTo->text().isEmpty() && ui->payTo_is->text().isEmpty() &&
            ui->payTo_s->text().isEmpty();
 }
 
 void SendCoinsEntry::setFocus() {
     ui->payTo->setFocus();
 }
 
 void SendCoinsEntry::updateDisplayUnit() {
     if (model && model->getOptionsModel()) {
         // Update payAmount with the current unit
         ui->payAmount->setDisplayUnit(
             model->getOptionsModel()->getDisplayUnit());
         ui->payAmount_is->setDisplayUnit(
             model->getOptionsModel()->getDisplayUnit());
         ui->payAmount_s->setDisplayUnit(
             model->getOptionsModel()->getDisplayUnit());
     }
 }
 
 bool SendCoinsEntry::updateLabel(const QString &address) {
     if (!model) {
         return false;
     }
 
     // Fill in label from address book, if address has an associated label
     QString associatedLabel =
         model->getAddressTableModel()->labelForAddress(address);
     if (!associatedLabel.isEmpty()) {
         ui->addAsLabel->setText(associatedLabel);
         return true;
     }
 
     return false;
 }