diff --git a/dashboard/src/components/MailDomainStatus.vue b/dashboard/src/components/MailDomainStatus.vue
index 347811f81..59f6d28c0 100644
--- a/dashboard/src/components/MailDomainStatus.vue
+++ b/dashboard/src/components/MailDomainStatus.vue
@@ -8,25 +8,18 @@ const props = defineProps([ 'domain' ]);
 
 const mailModel = MailModel.create();
 
-const expectedDnsRecordsTypes = [
-  { name: 'MX', value: 'mx' },
-  { name: 'DKIM', value: 'dkim' },
-  { name: 'SPF', value: 'spf' },
-  { name: 'DMARC', value: 'dmarc' },
-  { name: 'PTR4', value: 'ptr4' },
-  { name: 'PTR6', value: 'ptr6' },
-];
+const dnsRecordLabels = {
+  'mx': 'MX',
+  'dkim': 'DKIM',
+  'spf': 'SPF',
+  'dmarc': 'DMARC',
+  'ptr4': 'PTR4',
+  'ptr6': 'PTR6',
+};
 
-const expectedDnsRecords = ref({});
 const busy = ref(false);
 const mailConfig = ref({});
-const mailStatus = ref({});
-const relayStatusCollapsed = ref(true);
-const cloudronSmtpCollapsed = ref(true);
-
-function onToggleCollapsed(record) {
-  record.collapsed = !record.collapsed;
-}
+const domainStatus = ref({});
 
 async function refresh() {
   busy.value = true;
@@ -34,19 +27,12 @@ async function refresh() {
   let [error, result] = await mailModel.status(props.domain);
   if (error) return console.error(error);
 
-  mailStatus.value = result;
-
-  for (const type of expectedDnsRecordsTypes) {
-    expectedDnsRecords.value[type.value] = result.dns[type.value] || {};
-    expectedDnsRecords.value[type.value].collapsed = expectedDnsRecords.value[type.value].status;
-  }
+  domainStatus.value = result;
 
   [error, result] = await mailModel.config(props.domain);
   if (error) return console.error(error);
 
   mailConfig.value = result;
-  relayStatusCollapsed.value = true;
-  cloudronSmtpCollapsed.value = true;
 
   busy.value = false;
 }
@@ -58,42 +44,48 @@ onMounted(async () => {
 </script>
 
 <template>
-  <div>
+  <div v-if="domainStatus.mx">
     <h4>{{ $t('email.dnsStatus.title') }} &nbsp; <Button @click="refresh()" small tool icon="fa fa-sync-alt" :disabled="busy" :loading="busy"/></h4>
     <div v-html="$t('email.dnsStatus.description', { emailDnsDocsLink:'https://docs.cloudron.io/email/#dns-records'})"></div>
     <br/>
-    <div v-for="record in expectedDnsRecordsTypes" :key="record.value">
-      <div v-if="expectedDnsRecords[record.value]?.expected">
-        <div class="text-muted">
-          <i v-if="!busy" class="fa-solid" :class="{ 'fa-check-circle text-success': expectedDnsRecords[record.value].status, 'fa-exclamation-triangle text-danger': !expectedDnsRecords[record.value].status }"></i>
-          <i v-else class="fa-solid fa-circle-notch fa-spin"></i>
-          &nbsp;
-          <span class="actionable" @click="onToggleCollapsed(expectedDnsRecords[record.value])">{{ record.name }} record</span>
-        </div>
-        <div class="record-details" v-show="!expectedDnsRecords[record.value]?.collapsed">
-          <div v-if="record.name === 'MX' && domain.provider === 'namecheap'">{{ $t('email.dnsStatus.namecheapInfo') }} <sup><a href="https://docs.cloudron.io/domains/#namecheap-dns" class="help" target="_blank"><i class="fa fa-question-circle"></i></a></sup></div>
-          <div v-if="record.name === 'PTR4' || record.name === 'PTR6'">{{ $t('email.dnsStatus.ptrInfo') }} <sup><a href="https://docs.cloudron.io/email/#ptr-record" class="help" target="_blank"><i class="fa fa-question-circle"></i></a></sup></div>
+    <div v-for="(label, type) in dnsRecordLabels" :key="type">
+      <div class="text-muted">
+        <i v-if="!busy" class="fa-solid" :class="{
+          'fa-check-circle text-success': domainStatus[type].status === 'passed',
+          'fa-exclamation-triangle text-danger': domainStatus[type].status === 'failed',
+          'fa-minus text-success': domainStatus[type].status === 'skipped',
+          }"></i>
+        <i v-else class="fa-solid fa-circle-notch fa-spin"></i>
+        &nbsp;
+        <span>{{ label }} record</span>
+      </div>
+
+      <div class="record-details">
+        <div v-if="type === 'mx' && domain.provider === 'namecheap'">{{ $t('email.dnsStatus.namecheapInfo') }} <sup><a href="https://docs.cloudron.io/domains/#namecheap-dns" class="help" target="_blank"><i class="fa fa-question-circle"></i></a></sup></div>
+        <div v-if="type === 'ptr4' || type === 'ptr6'">{{ $t('email.dnsStatus.ptrInfo') }} <sup><a href="https://docs.cloudron.io/email/#ptr-record" class="help" target="_blank"><i class="fa fa-question-circle"></i></a></sup></div>
+        <div v-if="domainStatus[type].status === 'skipped'">{{ domainStatus[type].message }}</div>
+        <div v-else>
           <table>
             <tbody>
-              <tr v-if="expectedDnsRecords[record.value].name">
+              <tr>
                 <td>{{ $t('email.dnsStatus.hostname') }}:</td>
-                <td>{{ expectedDnsRecords[record.value].name }}</td>
+                <td>{{ domainStatus[type].name }}</td>
               </tr>
-              <tr v-if="!expectedDnsRecords[record.value].name">
+              <tr>
                 <td>{{ $t('email.dnsStatus.domain') }}:</td>
-                <td>{{ expectedDnsRecords[record.value].domain }}</td>
+                <td>{{ domainStatus[type].domain }}</td>
               </tr>
               <tr>
                 <td style="width: 10px;">{{ $t('email.dnsStatus.type') }}:</td>
-                <td>{{ expectedDnsRecords[record.value].type }}</td>
+                <td>{{ domainStatus[type].type }}</td>
               </tr>
               <tr>
                 <td>{{ $t('email.dnsStatus.expected') }}:</td>
-                <td>{{ expectedDnsRecords[record.value].expected }}</td>
+                <td>{{ domainStatus[type].expected }}</td>
               </tr>
               <tr>
                 <td>{{ $t('email.dnsStatus.current') }}:</td>
-                <td>{{ expectedDnsRecords[record.value].value ? expectedDnsRecords[record.value].value : ('['+('email.dnsStatus.recordNotSet' | tr)+']') }}</td>
+                <td>{{ domainStatus[type].value ? domainStatus[type].value : ('['+$t('email.dnsStatus.recordNotSet')+']') }}</td>
               </tr>
             </tbody>
           </table>
@@ -104,31 +96,42 @@ onMounted(async () => {
 
     <h4>{{ $t('email.smtpStatus.title') }} <sup><a href="https://docs.cloudron.io/email/#smtp-status" class="help" target="_blank"><i class="fa fa-question-circle"></i></a></sup></h4>
 
-    <div>
+    <div v-if="domainStatus.relay">
       <div class="text-muted">
-        <i v-if="!busy" class="fa" :class="{ 'fa-check-circle text-success': mailStatus.relay?.status, 'fa-exclamation-triangle text-danger': !mailStatus.relay?.status }"></i>
+        <i v-if="!busy" class="fa" :class="{
+          'fa-check-circle text-success': domainStatus.relay.status === 'passed',
+          'fa-exclamation-triangle text-danger': domainStatus.relay.status === 'failed',
+          'fa-minus text-success': domainStatus.relay.status === 'skipped',
+          }"></i>
         <i v-else class="fa-solid fa-circle-notch fa-spin"></i>
         &nbsp;
-        <span class="actionable" @click="relayStatusCollapsed = !relayStatusCollapsed">{{ $t(mailConfig.relay?.provider === 'cloudron-smtp' ? 'email.smtpStatus.outboudDirect' : 'email.smtpStatus.outboudRelay') }}</span>
+        <span>{{ $t('email.smtpStatus.outboundSmtp') }}</span>
       </div>
-      <div class="record-details" v-show="!relayStatusCollapsed">
-        <b>{{ mailStatus.relay?.value }}</b>
+      <div class="record-details">
+        {{ domainStatus.relay.message }}
       </div>
     </div>
 
-    <div v-if="mailConfig.relay?.provider === 'cloudron-smtp'">
+    <div v-if="domainStatus.rbl4">
       <div class="text-muted">
-        <i v-if="!busy" class="fa" :class="{ 'fa-check-circle text-success': mailStatus.rbl?.status, 'fa-exclamation-triangle text-danger': !mailStatus.rbl?.status }"></i>
+        <i v-if="!busy" class="fa" :class="{
+          'fa-check-circle text-success': domainStatus.rbl4.status === 'passed',
+          'fa-exclamation-triangle text-danger': domainStatus.rbl4.status === 'failed',
+          'fa-minus text-success': domainStatus.rbl4.status === 'skipped',
+          }"></i>
         <i v-else class="fa-solid fa-circle-notch fa-spin"></i>
         &nbsp;
-        <span class="actionable" @click="cloudronSmtpCollapsed = !cloudronSmtpCollapsed">{{ $t('email.smtpStatus.blacklistCheck') }}</span>
+        <span>{{ $t('email.smtpStatus.blacklistCheck') }}</span>
       </div>
-      <div class="record-details" v-show="!cloudronSmtpCollapsed">
-        <div v-if="mailStatus.rbl?.servers.length" v-html="$t('email.smtpStatus.blacklisted', { ip: mailStatus.rbl.ip })"></div>
-        <div v-else v-html="$t('email.smtpStatus.notBlacklisted', { ip: mailStatus.rbl?.ip })"></div>
+      <div class="record-details">
+        <div v-if="domainStatus.rbl4.status !== 'failed'">{{ domainStatus.rbl4.message }}</div>
+        <div v-else>
+          <div v-if="domainStatus.rbl4.servers.length" v-html="$t('email.smtpStatus.blacklisted', { ip: domainStatus.rbl4.ip })"></div>
+          <div v-else v-html="$t('email.smtpStatus.notBlacklisted', { ip: domainStatus.rbl4.ip })"></div>
 
-        <div v-for="server in mailStatus.rbl.servers" :key="server.name">
-          <a :href="server.site" target="_blank">{{ server.name }}</a>
+          <div v-for="server in domainStatus.rbl4.servers" :key="server.name">
+            <a :href="server.site" target="_blank">{{ server.name }}</a>
+          </div>
         </div>
       </div>
     </div>
diff --git a/dashboard/src/views/EmailStatusView.vue b/dashboard/src/views/EmailStatusView.vue
index 80d424dea..27a71cd46 100644
--- a/dashboard/src/views/EmailStatusView.vue
+++ b/dashboard/src/views/EmailStatusView.vue
@@ -31,9 +31,7 @@ async function refreshStatus(domain) {
     console.error(error);
   } else {
     domain.status = Object.keys(result).every((k) => {
-      if (k === 'dns') return Object.keys(result.dns).every(function (k) { return result.dns[k].status; });
-      if (!('status' in result[k])) return true; // if status is not present, the test was not run
-      return result[k].status;
+      return result[k].status === 'passed' || result[k].status === 'skipped';
     });
     domain.statusCheckDone = true;
   }
diff --git a/src/mail.js b/src/mail.js
index faa82a576..c778b5889 100644
--- a/src/mail.js
+++ b/src/mail.js
@@ -171,45 +171,30 @@ function validateDisplayName(name) {
 }
 
 async function checkOutboundPort25() {
-    const relay = {
-        value: 'OK',
-        status: false,
-        errorMessage: ''
-    };
-
     return await new Promise((resolve) => {
         const client = new net.Socket();
         client.setTimeout(5000);
         client.connect({ port: 25, host: constants.PORT25_CHECK_SERVER, family: 4 }); // family is 4 to keep it predictable
         client.on('connect', function () {
-            relay.status = true;
-            relay.value = 'OK';
             client.destroy(); // do not use end() because it still triggers timeout
-            resolve(relay);
+            resolve({ status: 'passed', message: 'Port 25 (outbound) is unblocked' });
         });
         client.on('timeout', function () {
-            relay.status = false;
-            relay.value = `Connect to ${constants.PORT25_CHECK_SERVER} timed out. Check if port 25 (outbound) is blocked`;
             client.destroy();
-            relay.errorMessage = `Connect to ${constants.PORT25_CHECK_SERVER} timed out.`;
-            resolve(relay);
+            resolve({ status: 'failed', message: `Connect to ${constants.PORT25_CHECK_SERVER} timed out. Check if port 25 (outbound) is blocked` });
         });
         client.on('error', function (error) {
-            relay.status = false;
-            relay.value = `Connect to ${constants.PORT25_CHECK_SERVER} failed: ${error.message}. Check if port 25 (outbound) is blocked`;
             client.destroy();
-            relay.errorMessage = `Connect to ${constants.PORT25_CHECK_SERVER} failed: ${error.message}`;
-            resolve(relay);
+            resolve({ status: 'failed', message: `Connect to ${constants.PORT25_CHECK_SERVER} failed: ${error.message}. Check if port 25 (outbound) is blocked` });
         });
     });
 }
 
 async function checkSmtpRelay(relay) {
-    const result = {
-        value: 'OK',
-        status: false,
-        errorMessage: ''
-    };
+    assert.strictEqual(typeof relay, 'object');
+
+    if (relay.provider === 'noop') return { status: 'skipped', message: 'Outbound disabled' };
+    if (relay.provider === 'cloudron-smtp') return await checkOutboundPort25();
 
     const options = {
         connectionTimeout: 5000,
@@ -233,133 +218,122 @@ async function checkSmtpRelay(relay) {
     const transporter = nodemailer.createTransport(options);
 
     const [error] = await safe(transporter.verify());
-    result.status = !error;
-    if (error) {
-        result.value = result.errorMessage = error.message;
-        return result;
-    }
+    const result = {
+        status: error ? 'failed' : 'passed',
+        message: error ? error.message : `Connection to ${relay.host}:${relay.port} succeeded`
+    };
 
     return result;
 }
 
-async function verifyRelay(relay) {
-    assert.strictEqual(typeof relay, 'object');
-
-    // we used to verify cloudron-smtp with checkOutboundPort25 but that is unreliable given that we just
-    // randomly select some smtp server
-    if (relay.provider === 'cloudron-smtp' || relay.provider === 'noop') return null;
-
-    const result = await checkSmtpRelay(relay);
-    if (result.errorMessage) return new BoxError(BoxError.BAD_FIELD, result.errorMessage);
-}
-
 async function checkDkim(mailDomain) {
     assert.strictEqual(typeof mailDomain, 'object');
 
-    const domain = mailDomain.domain;
-    const dkim = {
+    if (mailDomain.relay.provider === 'noop') return { status: 'skipped', message: 'Outbound disabled' };
+    if (mailDomain.relay.provider !== 'cloudron-smtp') return { status: 'skipped', message: 'DKIM check skipped, email is sent through a relay service' };
+
+    const { domain } = mailDomain;
+
+    const result = {
         domain: `${mailDomain.dkimSelector}._domainkey.${domain}`,
         name: `${mailDomain.dkimSelector}._domainkey`,
         type: 'TXT',
         expected: null,
         value: null,
-        status: false,
-        errorMessage: ''
+        status: 'failed',
+        message: ''
     };
 
     const publicKey = mailDomain.dkimKey.publicKey.split('\n').slice(1, -2).join(''); // remove header, footer and new lines
 
-    dkim.expected = `v=DKIM1; t=s; p=${publicKey}`;
+    result.expected = `v=DKIM1; t=s; p=${publicKey}`;
 
-    const [error, txtRecords] = await safe(dig.resolve(dkim.domain, dkim.type, DNS_OPTIONS));
-    if (error) {
-        dkim.errorMessage = error.message;
-        return dkim;
-    }
+    const [error, txtRecords] = await safe(dig.resolve(result.domain, result.type, DNS_OPTIONS));
+    if (error) return Object.assign(result, { status: 'failed', message: error.message });
+    if (txtRecords.length === 0) return Object.assign(result, { status: 'failed', message: 'No DKIM record' });
 
-    if (txtRecords.length !== 0) {
-        dkim.value = txtRecords[0].join('');
-        const actual = txtToDict(dkim.value);
-        dkim.status = actual.p === publicKey;
-    }
+    result.value = txtRecords[0].join('');
+    const actual = txtToDict(result.value);
+    result.status = actual.p === publicKey ? 'passed' : 'failed';
 
-    return dkim;
+    return result;
 }
 
-async function checkSpf(domain, mailFqdn) {
-    assert.strictEqual(typeof domain, 'string');
+async function checkSpf(mailDomain, mailFqdn) {
+    assert.strictEqual(typeof mailDomain, 'object');
     assert.strictEqual(typeof mailFqdn, 'string');
 
-    const spf = {
-        domain,
+    if (mailDomain.relay.provider === 'noop') return { status: 'skipped', message: 'Outbound disabled' };
+    if (mailDomain.relay.provider !== 'cloudron-smtp') return { status: 'skipped', message: 'SPF check skipped. Please check that the relay provider has correct SPF settings for this domain' };
+
+    const result = {
+        domain: mailDomain.domain,
         name: '@',
         type: 'TXT',
         value: null,
         expected: `v=spf1 a:${mailFqdn} ~all`,
-        status: false,
-        errorMessage: ''
+        status: 'failed',
+        message: ''
     };
 
-    const [error, txtRecords] = await safe(dig.resolve(spf.domain, spf.type, DNS_OPTIONS));
-    if (error) {
-        spf.errorMessage = error.message;
-        return spf;
-    }
+    const [error, txtRecords] = await safe(dig.resolve(result.domain, result.type, DNS_OPTIONS));
+    if (error) return Object.assign(result, { message: error.message });
 
     let i;
     for (i = 0; i < txtRecords.length; i++) {
         const txtRecord = txtRecords[i].join(''); // https://agari.zendesk.com/hc/en-us/articles/202952749-How-long-can-my-SPF-record-be-
         if (txtRecord.indexOf('v=spf1 ') !== 0) continue; // not SPF
-        spf.value = txtRecord;
-        spf.status = spf.value.indexOf(` a:${mailFqdn}`) !== -1;
+        result.value = txtRecord;
+        result.status = result.value.indexOf(` a:${mailFqdn}`) !== -1 ? 'passed' : 'failed';
         break;
     }
 
-    if (spf.status) {
-        spf.expected = spf.value;
+    if (result.status === 'passed') {
+        result.expected = result.value;
     } else if (i !== txtRecords.length) {
-        spf.expected = `v=spf1 a:${mailFqdn} ` + spf.value.slice('v=spf1 '.length);
+        result.expected = `v=spf1 a:${mailFqdn} ` + result.value.slice('v=spf1 '.length);
     }
 
-    return spf;
+    return result;
 }
 
-async function checkMx(domain, mailFqdn) {
-    assert.strictEqual(typeof domain, 'string');
+async function checkMx(mailDomain, mailFqdn) {
+    assert.strictEqual(typeof mailDomain, 'object');
     assert.strictEqual(typeof mailFqdn, 'string');
 
-    const mx = {
+    if (!mailDomain.enabled) return { status: 'skipped', message: 'MX check skipped, server does not handle incoming email for this domain' };
+
+    const { domain } = mailDomain;
+
+    const result = {
         domain,
         name: '@',
         type: 'MX',
         value: null,
         expected: `10 ${mailFqdn}.`,
-        status: false,
-        errorMessage: ''
+        status: 'failed',
+        message: ''
     };
 
-    const [error, mxRecords] = await safe(dig.resolve(mx.domain, mx.type, DNS_OPTIONS));
-    if (error) {
-        mx.errorMessage = error.message;
-        return mx;
-    }
-    if (mxRecords.length === 0) return mx;
+    const [error, mxRecords] = await safe(dig.resolve(result.domain, result.type, DNS_OPTIONS));
+    if (error) return Object.assign(result, { status: 'failed', message: error.message });
+    if (mxRecords.length === 0) return Object.assign(result, { status: 'failed', message: 'No MX record' });
 
-    mx.status = mxRecords.some(mx => mx.exchange === mailFqdn); // this lets use change priority and/or setup backup MX
-    mx.value = mxRecords.map(function (r) { return r.priority + ' ' + r.exchange + '.'; }).join(' ');
+    result.status = mxRecords.some(mx => mx.exchange === mailFqdn) ? 'passed' : 'failed'; // this lets use change priority and/or setup backup MX
+    result.value = mxRecords.map(function (r) { return r.priority + ' ' + r.exchange + '.'; }).join(' ');
 
-    if (mx.status) return mx; // MX record is "my."
+    if (result.status === 'passed') return result; // MX record is "my."
 
     // cloudflare might create a conflict subdomain (https://support.cloudflare.com/hc/en-us/articles/360020296512-DNS-Troubleshooting-FAQ)
     const [error2, mxIps] = await safe(dig.resolve(mxRecords[0].exchange, 'A', DNS_OPTIONS));
-    if (error2 || mxIps.length !== 1) return mx;
+    if (error2 || mxIps.length !== 1) return result;
 
     const [error3, ip] = await safe(network.getIPv4());
-    if (error3) return mx;
+    if (error3) return result;
 
-    mx.status = mxIps[0] === ip;
+    result.status = mxIps[0] === ip ? 'passed' : 'failed';
 
-    return mx;
+    return result;
 }
 
 function txtToDict(txt) {
@@ -371,57 +345,54 @@ function txtToDict(txt) {
     return dict;
 }
 
-async function checkDmarc(domain) {
+async function checkDmarc(mailDomain) {
+    assert.strictEqual(typeof mailDomain, 'object');
 
-    const dmarc = {
+    if (!mailDomain.enabled) return { status: 'skipped', message: 'DMARC check skipped, server does not handle incoming email for this domain' };
+
+    const { domain } = mailDomain;
+
+    const result = {
         domain: `_dmarc.${domain}`,
         name: '_dmarc',
         type: 'TXT',
         value: null,
         expected: 'v=DMARC1; p=reject; pct=100',
-        status: false,
-        errorMessage: ''
+        status: 'failed',
+        message: ''
     };
 
-    const [error, txtRecords] = await safe(dig.resolve(dmarc.domain, dmarc.type, DNS_OPTIONS));
+    const [error, txtRecords] = await safe(dig.resolve(result.domain, result.type, DNS_OPTIONS));
+    if (error) return Object.assign(result, { status: 'failed', message: error.message });
+    if (txtRecords.length === 0) return Object.assign(result, { status: 'failed', message: 'No DMARC records' });
 
-    if (error) {
-        dmarc.errorMessage = error.message;
-        return dmarc;
-    }
+    result.value = txtRecords[0].join('');
+    const actual = txtToDict(result.value);
+    result.status = actual.v === 'DMARC1' ? 'passed' : 'failed'; // see box#666
 
-    if (txtRecords.length !== 0) {
-        dmarc.value = txtRecords[0].join('');
-        const actual = txtToDict(dmarc.value);
-        dmarc.status = actual.v === 'DMARC1'; // see box#666
-    }
-
-    return dmarc;
+    return result;
 }
 
-async function checkPtr6(mailFqdn) {
+async function checkPtr6(mailDomain, mailFqdn) {
+    assert.strictEqual(typeof mailDomain, 'object');
     assert.strictEqual(typeof mailFqdn, 'string');
 
-    const ptr = {
+    if (mailDomain.relay.provider === 'noop') return { status: 'skipped', message: 'Outbound disabled' };
+    if (mailDomain.relay.provider !== 'cloudron-smtp') return { status: 'skipped', message: 'PTR6 check was skipped, email is sent through a relay service' };
+
+    const result = {
         domain: null,
         name: null,
         type: 'PTR',
         value: null,
         expected: mailFqdn, // any trailing '.' is added by client software (https://lists.gt.net/spf/devel/7918)
-        status: false,
-        errorMessage: ''
+        status: 'failed',
+        message: ''
     };
 
     const [error, ip] = await safe(network.getIPv6());
-    if (error) {
-        ptr.errorMessage = error.message;
-        return ptr;
-    }
-    if (ip === null) {
-        ptr.status = true;
-        ptr.expected = 'Check skipped, server has no IPv6';
-        return ptr;
-    }
+    if (error) return Object.assign(result, { status: 'failed', message: error.message });
+    if (ip === null) return Object.assign(result, { status: 'skipped', message: 'PTR6 check was skipped, server has no IPv6' });
 
     function expandIPv6(ipv6) {
         const parts = ipv6.split('::');
@@ -436,65 +407,54 @@ async function checkPtr6(mailFqdn) {
     const reversed = expanded.split('').reverse().join('');
     const reversedWithDots = reversed.split('').join('.');
 
-    ptr.domain = `${reversedWithDots}.ip6.arpa`;
-    ptr.name = ip;
+    result.domain = `${reversedWithDots}.ip6.arpa`;
+    result.name = ip;
 
-    const [error2, ptrRecords] = await safe(dig.resolve(ptr.domain, 'PTR', DNS_OPTIONS));
-    if (error2) {
-        ptr.errorMessage = error2.message;
-        return ptr;
-    }
+    const [error2, ptrRecords] = await safe(dig.resolve(result.domain, 'PTR', DNS_OPTIONS));
+    if (error2) return Object.assign(result, { status: 'failed', message: error2.message });
+    if (ptrRecords.length === 0) return Object.assign(result, { status: 'failed', message: 'No PTR6 record' });
 
-    if (ptrRecords.length !== 0) {
-        ptr.value = ptrRecords.join(' ');
-        ptr.status = ptrRecords.some(function (v) { return v === ptr.expected; });
-    }
+    result.value = ptrRecords.join(' ');
+    result.status = ptrRecords.some(function (v) { return v === result.expected; }) ? 'passed' : 'failed';
 
-    return ptr;
+    return result;
 }
 
-async function checkPtr4(mailFqdn) {
+async function checkPtr4(mailDomain, mailFqdn) {
+    assert.strictEqual(typeof mailDomain, 'object');
     assert.strictEqual(typeof mailFqdn, 'string');
 
-    const ptr = {
+    if (mailDomain.relay.provider === 'noop') return { status: 'skipped', message: 'Outbound disabled' };
+    if (mailDomain.relay.provider !== 'cloudron-smtp') return { status: 'skipped', message: 'PTR4 check was skipped, email is sent through a relay service' };
+
+    const result = {
         domain: null,
         name: null,
         type: 'PTR',
         value: null,
         expected: mailFqdn, // any trailing '.' is added by client software (https://lists.gt.net/spf/devel/7918)
-        status: false,
-        errorMessage: ''
+        status: 'failed',
+        message: ''
     };
 
     const [error, ip] = await safe(network.getIPv4());
-    if (error) {
-        ptr.errorMessage = error.message;
-        return ptr;
-    }
-    if (ip === null) {
-        ptr.status = true;
-        ptr.expected = 'Check skipped, server has no IPv4';
-        return ptr;
-    }
+    if (error) return Object.assign(result, { status: 'failed', message: error.message });
+    if (ip === null) return Object.assign(result, { status: 'skipped', message: 'PTR4 check was skipped, server has no IPv4' });
 
-    ptr.domain = ip.split('.').reverse().join('.') + '.in-addr.arpa';
-    ptr.name = ip;
+    result.domain = ip.split('.').reverse().join('.') + '.in-addr.arpa';
+    result.name = ip;
 
-    const [error2, ptrRecords] = await safe(dig.resolve(ptr.domain, 'PTR', DNS_OPTIONS));
-    if (error2) {
-        ptr.errorMessage = error2.message;
-        return ptr;
-    }
+    const [error2, ptrRecords] = await safe(dig.resolve(result.domain, 'PTR', DNS_OPTIONS));
+    if (error2) return Object.assign(result, { status: 'failed', message: error2.message });
+    if (ptrRecords.length === 0) return Object.assign(result, { status: 'failed', message: 'No PTR4 record' });
 
-    if (ptrRecords.length !== 0) {
-        ptr.value = ptrRecords.join(' ');
-        ptr.status = ptrRecords.some(function (v) { return v === ptr.expected; });
-    }
+    result.value = ptrRecords.join(' ');
+    result.status = ptrRecords.some(function (v) { return v === result.expected; }) ? 'passed' : 'failed';
 
-    return ptr;
+    return result;
 }
 
-// https://raw.githubusercontent.com/jawsome/node-dnsbl/master/list.json
+// https://raw.githubusercontent.com/jawsome/node-dnsbl/master/list.json https://multirbl.valli.org/list/
 const RBL_LIST = [
     {
         'name': 'Abuse.ch',
@@ -550,12 +510,17 @@ const RBL_LIST = [
 ];
 
 // this function currently only looks for black lists based on IP. TODO: also look up by domain
-async function checkRblStatus(domain) {
+async function checkRbl4(mailDomain) {
+    assert.strictEqual(typeof mailDomain, 'object');
+
+    if (mailDomain.relay.provider === 'noop') return { status: 'skipped', message: 'Outbound disabled' };
+    if (mailDomain.relay.provider !== 'cloudron-smtp') return { status: 'skipped', message: 'RBL check was skipped, email is sent through a relay service' };
+
+    const { domain } = mailDomain;
+
     const [error, ip] = await safe(network.getIPv4());
-    if (error) {
-        debug(`checkRblStatus: unable to determine server IPv4: ${error.message}`);
-        return { status: false, ip: null, servers: [] };
-    }
+    if (error) return { status: 'failed', ip: null, servers: [], message: `Unable to determine server IPv4: ${error.message}` };
+    if (ip === null) return { status: 'skipped', ip: null, servers: [], message: 'RBL check was skipped, server has no IPv4' };
 
     const flippedIp = ip.split('.').reverse().join('.');
 
@@ -579,48 +544,34 @@ async function checkRblStatus(domain) {
 
     debug(`checkRblStatus: ${domain} (ip: ${ip}) blockedServers: ${JSON.stringify(blockedServers)})`);
 
-    return { status: blockedServers.length === 0, ip, servers: blockedServers };
+    return { status: blockedServers.length === 0 ? 'passed' : 'failed', ip, servers: blockedServers };
 }
 
 async function getStatus(domain) {
     assert.strictEqual(typeof domain, 'string');
 
-    // ensure we always have a valid toplevel properties for the api
-    const results = {
-        dns: {}, // { mx/dmarc/dkim/spf/ptr: { expected, value, name, domain, type, status } }
-        rbl: {}, // { status, ip, servers: [{name,site,dns}]} optional. only for cloudron-smtp
-        relay: {} // { status, value } always checked
-    };
-
     const { fqdn } = await mailServer.getLocation();
 
     const mailDomain = await getDomain(domain);
     if (!mailDomain) throw new BoxError(BoxError.NOT_FOUND, 'mail domain not found');
 
-    const checks = [];
-    if (mailDomain.enabled) {
-        checks.push(
-            { what: 'dns.mx', promise: checkMx(domain, fqdn) },
-            { what: 'dns.dmarc', promise: checkDmarc(domain) }
-        );
-    }
+    // mx/dmarc/dkim/spf/ptr: { expected, value, name, domain, type, status } }
+    // rbl4: { status, ip, servers: [{name,site,dns}]}
+    // relay: { status, message } always checked
+    const results = {};
 
-    if (mailDomain.relay.provider === 'cloudron-smtp') {
-        // these tests currently only make sense when using Cloudron's SMTP server at this point
-        checks.push(
-            { what: 'dns.spf', promise: checkSpf(domain, fqdn) },
-            { what: 'dns.dkim', promise: checkDkim(mailDomain) },
-            { what: 'dns.ptr4', promise: checkPtr4(fqdn) },
-            { what: 'dns.ptr6', promise: checkPtr6(fqdn) },
-            { what: 'relay', promise: checkOutboundPort25() },
-            { what: 'rbl', promise: checkRblStatus(domain) },
-        );
-    } else if (mailDomain.relay.provider !== 'noop') {
-        checks.push({ what: 'relay', promise: checkSmtpRelay(mailDomain.relay) });
-    }
+    const checks = [
+        { what: 'mx', promise: checkMx(mailDomain, fqdn) },
+        { what: 'dmarc', promise: checkDmarc(mailDomain) },
+        { what: 'spf', promise: checkSpf(mailDomain, fqdn) },
+        { what: 'dkim', promise: checkDkim(mailDomain) },
+        { what: 'ptr4', promise: checkPtr4(mailDomain, fqdn) },
+        { what: 'ptr6', promise: checkPtr6(mailDomain, fqdn) },
+        { what: 'rbl4', promise: checkRbl4(mailDomain) },
+        { what: 'relay', promise: checkSmtpRelay(mailDomain.relay) }
+    ];
 
-    // wait for all the checks and record the result
-    const responses = await Promise.allSettled(checks.map(c => c.promise));
+    const responses = await Promise.allSettled(checks.map(c => c.promise)); // wait for all the checks and record the result
     for (let i = 0; i < checks.length; i++) {
         const response = responses[i], check = checks[i];
         if (response.status !== 'fulfilled') {
@@ -628,7 +579,7 @@ async function getStatus(domain) {
             continue;
         }
 
-        if (response.value.errorMessage) debug(`Ignored error - ${check.what} : ${response.value.errorMessage}`);
+        if (response.value.message) debug(`${check.what} : ${response.value.message}`);
         safe.set(results, checks[i].what, response.value || {});
     }
 
@@ -842,8 +793,8 @@ async function setMailRelay(domain, relay, options) {
     if (relay.password === constants.SECRET_PLACEHOLDER) relay.password = result.relay.password;
 
     if (!options.skipVerify) {
-        const error = await verifyRelay(relay);
-        if (error) throw error;
+        const result = await checkSmtpRelay(relay);
+        if (result.status === 'failed') throw new BoxError(BoxError.BAD_FIELD, result.message);
     }
 
     await updateDomain(domain, { relay });
diff --git a/src/routes/test/mail-test.js b/src/routes/test/mail-test.js
index 17f97a2ca..93da5b647 100644
--- a/src/routes/test/mail-test.js
+++ b/src/routes/test/mail-test.js
@@ -114,32 +114,32 @@ describe('Mail API', function () {
             expect(response.body.dns.dkim.type).to.eql('TXT');
             expect(response.body.dns.dkim.value).to.eql(null);
             expect(response.body.dns.dkim.expected).to.eql(`v=DKIM1; t=s; p=${publicKey}`);
-            expect(response.body.dns.dkim.status).to.eql(false);
+            expect(response.body.dns.dkim.status).to.eql('failed');
 
             expect(response.body.dns.spf).to.be.an('object');
             expect(response.body.dns.spf.domain).to.eql(spfDomain);
             expect(response.body.dns.spf.type).to.eql('TXT');
             expect(response.body.dns.spf.value).to.eql(null);
             expect(response.body.dns.spf.expected).to.eql(`v=spf1 a:${dashboardFqdn} ~all`);
-            expect(response.body.dns.spf.status).to.eql(false);
+            expect(response.body.dns.spf.status).to.eql('failed');
 
             expect(response.body.dns.dmarc).to.be.an('object');
             expect(response.body.dns.dmarc.type).to.eql('TXT');
             expect(response.body.dns.dmarc.value).to.eql(null);
             expect(response.body.dns.dmarc.expected).to.eql('v=DMARC1; p=reject; pct=100');
-            expect(response.body.dns.dmarc.status).to.eql(false);
+            expect(response.body.dns.dmarc.status).to.eql('failed');
 
             expect(response.body.dns.mx).to.be.an('object');
             expect(response.body.dns.mx.type).to.eql('MX');
             expect(response.body.dns.mx.value).to.eql(null);
             expect(response.body.dns.mx.expected).to.eql(`10 ${mailFqdn}.`);
-            expect(response.body.dns.mx.status).to.eql(false);
+            expect(response.body.dns.mx.status).to.eql('failed');
 
             expect(response.body.dns.ptr4).to.be.an('object');
             expect(response.body.dns.ptr4.type).to.eql('PTR');
             // expect(response.body.ptr.value).to.eql(null); this will be anything random
             expect(response.body.dns.ptr4.expected).to.eql(mailFqdn);
-            expect(response.body.dns.ptr4.status).to.eql(false);
+            expect(response.body.dns.ptr4.status).to.eql('failed');
         });
 
         it('succeeds with "undefined" spf, dkim, dmarc, mx, ptr records', async function () {
@@ -157,27 +157,27 @@ describe('Mail API', function () {
 
             expect(response.body.dns.spf).to.be.an('object');
             expect(response.body.dns.spf.expected).to.eql(`v=spf1 a:${dashboardFqdn} ~all`);
-            expect(response.body.dns.spf.status).to.eql(false);
+            expect(response.body.dns.spf.status).to.eql('failed');
             expect(response.body.dns.spf.value).to.eql(null);
 
             expect(response.body.dns.dkim).to.be.an('object');
             expect(response.body.dns.dkim.expected).to.eql(`v=DKIM1; t=s; p=${publicKey}`);
-            expect(response.body.dns.dkim.status).to.eql(false);
+            expect(response.body.dns.dkim.status).to.eql('failed');
             expect(response.body.dns.dkim.value).to.eql(null);
 
             expect(response.body.dns.dmarc).to.be.an('object');
             expect(response.body.dns.dmarc.expected).to.eql('v=DMARC1; p=reject; pct=100');
-            expect(response.body.dns.dmarc.status).to.eql(false);
+            expect(response.body.dns.dmarc.status).to.eql('failed');
             expect(response.body.dns.dmarc.value).to.eql(null);
 
             expect(response.body.dns.mx).to.be.an('object');
-            expect(response.body.dns.mx.status).to.eql(false);
+            expect(response.body.dns.mx.status).to.eql('failed');
             expect(response.body.dns.mx.expected).to.eql(`10 ${mailFqdn}.`);
             expect(response.body.dns.mx.value).to.eql(null);
 
             expect(response.body.dns.ptr4).to.be.an('object');
             expect(response.body.dns.ptr4.expected).to.eql(mailFqdn);
-            expect(response.body.dns.ptr4.status).to.eql(false);
+            expect(response.body.dns.ptr4.status).to.eql('failed');
             // expect(response.body.ptr.value).to.eql(null); this will be anything random
         });
 
@@ -196,27 +196,27 @@ describe('Mail API', function () {
 
             expect(response.body.dns.spf).to.be.an('object');
             expect(response.body.dns.spf.expected).to.eql(`v=spf1 a:${dashboardFqdn} a:random.com ~all`);
-            expect(response.body.dns.spf.status).to.eql(false);
+            expect(response.body.dns.spf.status).to.eql('failed');
             expect(response.body.dns.spf.value).to.eql('v=spf1 a:random.com ~all');
 
             expect(response.body.dns.dkim).to.be.an('object');
             expect(response.body.dns.dkim.expected).to.eql('v=DKIM1; t=s; p=' + publicKey);
-            expect(response.body.dns.dkim.status).to.eql(true); // as long as p= matches we are good
+            expect(response.body.dns.dkim.status).to.eql('passed'); // as long as p= matches we are good
             expect(response.body.dns.dkim.value).to.eql('v=DKIM2; t=s; p=' + publicKey);
 
             expect(response.body.dns.dmarc).to.be.an('object');
             expect(response.body.dns.dmarc.expected).to.eql('v=DMARC1; p=reject; pct=100');
-            expect(response.body.dns.dmarc.status).to.eql(false);
+            expect(response.body.dns.dmarc.status).to.eql('failed');
             expect(response.body.dns.dmarc.value).to.eql('v=DMARC2; p=reject; pct=100');
 
             expect(response.body.dns.mx).to.be.an('object');
-            expect(response.body.dns.mx.status).to.eql(true);
+            expect(response.body.dns.mx.status).to.eql('passed');
             expect(response.body.dns.mx.expected).to.eql(`10 ${mailFqdn}.`);
             expect(response.body.dns.mx.value).to.eql(`20 ${mailFqdn}. 10 some.other.server.`);
 
             expect(response.body.dns.ptr4).to.be.an('object');
             expect(response.body.dns.ptr4.expected).to.eql(mailFqdn);
-            expect(response.body.dns.ptr4.status).to.eql(false);
+            expect(response.body.dns.ptr4.status).to.eql('failed');
             // expect(response.body.ptr.value).to.eql(null); this will be anything random
 
             expect(response.body.relay).to.be.an('object');
@@ -237,7 +237,7 @@ describe('Mail API', function () {
             expect(response.body.dns.spf.type).to.eql('TXT');
             expect(response.body.dns.spf.value).to.eql(`v=spf1 a:example.com a:${mailFqdn} ~all`);
             expect(response.body.dns.spf.expected).to.eql(`v=spf1 a:example.com a:${mailFqdn} ~all`);
-            expect(response.body.dns.spf.status).to.eql(true);
+            expect(response.body.dns.spf.status).to.eql('passed');
         });
 
         it('succeeds with modified DMARC1 values', async function () {
@@ -252,7 +252,7 @@ describe('Mail API', function () {
 
             expect(response.body.dns.dmarc).to.be.an('object');
             expect(response.body.dns.dmarc.expected).to.eql('v=DMARC1; p=reject; pct=100');
-            expect(response.body.dns.dmarc.status).to.eql(true);
+            expect(response.body.dns.dmarc.status).to.eql('passed');
             expect(response.body.dns.dmarc.value).to.eql('v=DMARC1; p=reject; rua=mailto:rua@example.com; pct=100');
         });
 
@@ -274,22 +274,22 @@ describe('Mail API', function () {
             expect(response.body.dns.dkim.type).to.eql('TXT');
             expect(response.body.dns.dkim.value).to.eql(`v=DKIM1; t=s; p=${publicKey}`);
             expect(response.body.dns.dkim.expected).to.eql(`v=DKIM1; t=s; p=${publicKey}`);
-            expect(response.body.dns.dkim.status).to.eql(true);
+            expect(response.body.dns.dkim.status).to.eql('passed');
 
             expect(response.body.dns.spf).to.be.an('object');
             expect(response.body.dns.spf.domain).to.eql(spfDomain);
             expect(response.body.dns.spf.type).to.eql('TXT');
             expect(response.body.dns.spf.value).to.eql(`v=spf1 a:${dashboardFqdn} ~all`);
             expect(response.body.dns.spf.expected).to.eql(`v=spf1 a:${dashboardFqdn} ~all`);
-            expect(response.body.dns.spf.status).to.eql(true);
+            expect(response.body.dns.spf.status).to.eql('passed');
 
             expect(response.body.dns.dmarc).to.be.an('object');
             expect(response.body.dns.dmarc.expected).to.eql('v=DMARC1; p=reject; pct=100');
-            expect(response.body.dns.dmarc.status).to.eql(true);
+            expect(response.body.dns.dmarc.status).to.eql('passed');
             expect(response.body.dns.dmarc.value).to.eql('v=DMARC1; p=reject; pct=100');
 
             expect(response.body.dns.mx).to.be.an('object');
-            expect(response.body.dns.mx.status).to.eql(true);
+            expect(response.body.dns.mx.status).to.eql('passed');
             expect(response.body.dns.mx.expected).to.eql(`10 ${mailFqdn}.`);
             expect(response.body.dns.mx.value).to.eql(`10 ${mailFqdn}.`);
         });