diff --git a/src/app/Jobs/User/CreateJob.php b/src/app/Jobs/User/CreateJob.php
index 96e4fc93..f97117f6 100644
--- a/src/app/Jobs/User/CreateJob.php
+++ b/src/app/Jobs/User/CreateJob.php
@@ -1,102 +1,107 @@
 <?php
 
 namespace App\Jobs\User;
 
 use App\Jobs\UserJob;
 
 /**
  * Create the \App\User in LDAP.
  *
  * Throws exceptions for the following reasons:
  *
  *   * The user is marked as deleted (`$user->isDeleted()`), or
  *   * the user is actually deleted (`$user->deleted_at`), or
  *   * the user is already marked as ready in LDAP (`$user->isLdapReady()`).
  *
  */
 class CreateJob extends UserJob
 {
     /**
      * Execute the job.
      *
      * @return void
      *
      * @throws \Exception
      */
     public function handle()
     {
         $user = $this->getUser();
 
         if (!$user) {
             return;
         }
 
         if ($user->role) {
             // Admins/resellers don't reside in LDAP (for now)
             return;
         }
 
+        if ($user->email == \config('imap.admin_login')) {
+            // Ignore Cyrus admin account
+            return;
+        }
+
         // sanity checks
         if ($user->isDeleted()) {
             $this->fail(new \Exception("User {$this->userId} is marked as deleted."));
             return;
         }
 
         if ($user->trashed()) {
             $this->fail(new \Exception("User {$this->userId} is actually deleted."));
             return;
         }
 
         $withLdap = \config('app.with_ldap');
 
         // see if the domain is ready
         $domain = $user->domain();
 
         if (!$domain) {
             $this->fail(new \Exception("The domain for {$this->userId} does not exist."));
             return;
         }
 
         if ($domain->isDeleted()) {
             $this->fail(new \Exception("The domain for {$this->userId} is marked as deleted."));
             return;
         }
 
         if ($withLdap && !$domain->isLdapReady()) {
             $this->release(60);
             return;
         }
 
         if (\config('abuse.suspend_enabled')) {
             $code = \Artisan::call("user:abuse-check {$this->userId}");
             if ($code == 2) {
                 \Log::info("Suspending user due to suspected abuse: {$this->userId} {$user->email}");
                 $user->status |= \App\User::STATUS_SUSPENDED;
             }
         }
 
         if ($withLdap && !$user->isLdapReady()) {
             \App\Backends\LDAP::createUser($user);
 
             $user->status |= \App\User::STATUS_LDAP_READY;
             $user->save();
         }
 
         if (!$user->isImapReady()) {
             if (\config('app.with_imap')) {
                 if (!\App\Backends\IMAP::createUser($user)) {
                     throw new \Exception("Failed to create mailbox for user {$this->userId}.");
                 }
             } else {
                 if (!\App\Backends\IMAP::verifyAccount($user->email)) {
                     throw new \Exception("Failed to find the mailbox for user {$this->userId}.");
                 }
             }
 
             $user->status |= \App\User::STATUS_IMAP_READY;
         }
 
         $user->status |= \App\User::STATUS_ACTIVE;
         $user->save();
     }
 }
diff --git a/src/database/seeds/local/UserSeeder.php b/src/database/seeds/local/UserSeeder.php
index f74ffeae..b93db82f 100644
--- a/src/database/seeds/local/UserSeeder.php
+++ b/src/database/seeds/local/UserSeeder.php
@@ -1,250 +1,250 @@
 <?php
 
 namespace Database\Seeds\Local;
 
 use App\Auth\SecondFactor;
 use App\Domain;
 use App\Entitlement;
 use App\User;
 use App\Sku;
 use Carbon\Carbon;
 use Illuminate\Database\Seeder;
 use App\Wallet;
 
 class UserSeeder extends Seeder
 {
     /**
      * Run the database seeds.
      *
      * @return void
      */
     public function run()
     {
         $domain = Domain::create(
             [
                 'namespace' => 'kolab.org',
                 'status' => Domain::STATUS_NEW
                     + Domain::STATUS_ACTIVE
                     + Domain::STATUS_CONFIRMED
                     + Domain::STATUS_VERIFIED,
                 'type' => Domain::TYPE_EXTERNAL
             ]
         );
 
         $john = User::create(
             [
                 'email' => 'john@kolab.org',
                 'password' => \App\Utils::generatePassphrase()
             ]
         );
 
         $john->setSettings(
             [
                 'first_name' => 'John',
                 'last_name' => 'Doe',
                 'currency' => 'USD',
                 'country' => 'US',
                 'billing_address' => "601 13th Street NW\nSuite 900 South\nWashington, DC 20005",
                 'external_email' => 'john.doe.external@gmail.com',
                 'organization' => 'Kolab Developers',
                 'phone' => '+1 509-248-1111',
             ]
         );
 
         $john->setAliases(['john.doe@kolab.org']);
 
         $wallet = $john->wallets->first();
 
         $packageDomain = \App\Package::withEnvTenantContext()->where('title', 'domain-hosting')->first();
         $packageKolab = \App\Package::withEnvTenantContext()->where('title', 'kolab')->first();
         $packageLite = \App\Package::withEnvTenantContext()->where('title', 'lite')->first();
 
         $domain->assignPackage($packageDomain, $john);
         $john->assignPackage($packageKolab);
 
 
         $appDomain = \App\Domain::where(
             [
                 'namespace' => \config('app.domain')
             ]
         )->first();
 
         $fred = User::create(
             [
                 'email' => 'fred@' . \config('app.domain'),
                 'password' => \App\Utils::generatePassphrase()
             ]
         );
 
         $fred->setSettings(
             [
                 'first_name' => 'fred',
                 'last_name' => 'Doe',
                 'currency' => 'USD',
                 'country' => 'US',
                 'billing_address' => "601 13th Street NW\nSuite 900 South\nWashington, DC 20005",
                 'external_email' => 'fred.doe.external@gmail.com',
                 'organization' => 'Kolab Developers',
                 'phone' => '+1 509-248-1111',
             ]
         );
 
         $appDomain->assignPackage($packageDomain, $fred);
         $fred->assignPackage($packageKolab);
 
 
         $jack = User::create(
             [
                 'email' => 'jack@kolab.org',
                 'password' => \App\Utils::generatePassphrase()
             ]
         );
 
         $jack->setSettings(
             [
                 'first_name' => 'Jack',
                 'last_name' => 'Daniels',
                 'currency' => 'USD',
                 'country' => 'US'
             ]
         );
 
         $jack->setAliases(['jack.daniels@kolab.org']);
 
         $john->assignPackage($packageKolab, $jack);
 
         foreach ($john->entitlements as $entitlement) {
             $entitlement->created_at = Carbon::now()->subMonthsWithoutOverflow(1);
             $entitlement->updated_at = Carbon::now()->subMonthsWithoutOverflow(1);
             $entitlement->save();
         }
 
         $ned = User::create(
             [
                 'email' => 'ned@kolab.org',
                 'password' => \App\Utils::generatePassphrase()
             ]
         );
 
         $ned->setSettings(
             [
                 'first_name' => 'Edward',
                 'last_name' => 'Flanders',
                 'currency' => 'USD',
                 'country' => 'US',
                 'guam_enabled' => false,
             ]
         );
 
         $john->assignPackage($packageKolab, $ned);
 
         $ned->assignSku(\App\Sku::withEnvTenantContext()->where('title', 'activesync')->first(), 1);
 
         // Ned is a controller on Jack's wallet
         $john->wallets()->first()->addController($ned);
 
         // Ned is also our 2FA test user
         $sku2fa = Sku::withEnvTenantContext()->where('title', '2fa')->first();
 
         $ned->assignSku($sku2fa);
 
         SecondFactor::seed('ned@kolab.org');
 
         $joe = User::create(
             [
                 'email' => 'joe@kolab.org',
                 'password' => \App\Utils::generatePassphrase()
             ]
         );
 
         $john->assignPackage($packageLite, $joe);
 
         //$john->assignSku(Sku::firstOrCreate(['title' => 'beta']));
         //$john->assignSku(Sku::firstOrCreate(['title' => 'meet']));
 
         $joe->setAliases(['joe.monster@kolab.org']);
 
         // This only exists so the user create job doesn't fail because the domain is not found
         Domain::create(
             [
                 'namespace' => 'jeroen.jeroen',
                 'status' => Domain::STATUS_NEW
                     + Domain::STATUS_ACTIVE
                     + Domain::STATUS_CONFIRMED
                     + Domain::STATUS_VERIFIED,
                 'type' => Domain::TYPE_EXTERNAL
             ]
         );
 
         $jeroen = User::create(
             [
                 'email' => 'jeroen@jeroen.jeroen',
                 'password' => \App\Utils::generatePassphrase()
             ]
         );
 
         $jeroen->role = 'admin';
         $jeroen->save();
 
         $reseller = User::create(
             [
                 'email' => 'reseller@' . \config('app.domain'),
                 'password' => \App\Utils::generatePassphrase()
             ]
         );
 
         $reseller->role = 'reseller';
         $reseller->save();
 
         $reseller->assignPackage($packageKolab);
 
         // for tenants that are not the configured tenant id
         $tenants = \App\Tenant::where('id', '!=', \config('app.tenant_id'))->get();
 
         foreach ($tenants as $tenant) {
             $domain = Domain::where('tenant_id', $tenant->id)->first();
 
             $packageKolab = \App\Package::where(
                 [
                     'title' => 'kolab',
                     'tenant_id' => $tenant->id
                 ]
             )->first();
 
             if ($domain) {
                 $reseller = User::create(
                     [
                         'email' => 'reseller@' . $domain->namespace,
                         'password' => \App\Utils::generatePassphrase()
                     ]
                 );
 
                 $reseller->role = 'reseller';
                 $reseller->tenant_id = $tenant->id;
                 $reseller->save();
 
                 $reseller->assignPackage($packageKolab);
 
                 $user = User::create(
                     [
                         'email' => 'user@' . $domain->namespace,
                         'password' => \App\Utils::generatePassphrase()
                     ]
                 );
 
                 $user->tenant_id = $tenant->id;
                 $user->save();
 
                 $user->assignPackage($packageKolab);
             }
         }
 
-        # Create imap admin service account
+        // Create imap admin service account
         User::create(
             [
                 'email' => \config('imap.admin_login'),
                 'password' => \config('imap.admin_password')
             ]
         );
     }
 }