diff --git a/core/lib/Drupal/Core/Field/FieldTypePluginManager.php b/core/lib/Drupal/Core/Field/FieldTypePluginManager.php
index 905cdb4f1b..43b3d311f3 100644
--- a/core/lib/Drupal/Core/Field/FieldTypePluginManager.php
+++ b/core/lib/Drupal/Core/Field/FieldTypePluginManager.php
@@ -136,13 +136,10 @@ public function getUiDefinitions() {
     foreach ($definitions as $id => $definition) {
       if (is_subclass_of($definition['class'], '\Drupal\Core\Field\PreconfiguredFieldUiOptionsInterface')) {
         foreach ($definition['class']::getPreconfiguredOptions() as $key => $option) {
-          $definitions['field_ui:' . $id . ':' . $key] = [
-            'label' => $option['label'],
-          ] + $definition;
-
-          if (isset($option['category'])) {
-            $definitions['field_ui:' . $id . ':' . $key]['category'] = $option['category'];
-          }
+          $definitions["field_ui:$id:$key"] = array_intersect_key(
+            $option,
+            ['label' => 0, 'category' => 1]
+          ) + $definition;
         }
       }
     }
diff --git a/core/lib/Drupal/Core/Field/FieldTypePluginManagerInterface.php b/core/lib/Drupal/Core/Field/FieldTypePluginManagerInterface.php
index 3a5c7b546c..6d260451e3 100644
--- a/core/lib/Drupal/Core/Field/FieldTypePluginManagerInterface.php
+++ b/core/lib/Drupal/Core/Field/FieldTypePluginManagerInterface.php
@@ -79,6 +79,11 @@ public function getDefaultStorageSettings($type);
   /**
    * Gets the definition of all field types that can be added via UI.
    *
+   * If the field type extends
+   * \Drupal\Core\Field\PreconfiguredFieldUiOptionsInterface, then include the
+   * preconfigured definitions. The key is 'field_ui', the base field name, and
+   * the key from getPreconfiguredOptions(), joined with ':'.
+   *
    * @return array
    *   An array of field type definitions.
    */
diff --git a/core/modules/field_ui/src/Form/FieldStorageAddForm.php b/core/modules/field_ui/src/Form/FieldStorageAddForm.php
index 5e5a842282..4d24064877 100644
--- a/core/modules/field_ui/src/Form/FieldStorageAddForm.php
+++ b/core/modules/field_ui/src/Form/FieldStorageAddForm.php
@@ -2,6 +2,7 @@
 
 namespace Drupal\field_ui\Form;
 
+use Drupal\Component\Utility\Html;
 use Drupal\Core\Config\ConfigFactoryInterface;
 use Drupal\Core\Entity\EntityManagerInterface;
 use Drupal\Core\Field\FieldTypePluginManagerInterface;
@@ -121,7 +122,7 @@ public function buildForm(array $form, FormStateInterface $form_state, $entity_t
     ];
 
     // Re-use existing field.
-    if ($existing_field_storage_options = $this->getExistingFieldStorageOptions()) {
+    if ($existing_field_storage_options = $this->getExistingFieldOptions()) {
       $form['add']['separator'] = [
         '#type' => 'item',
         '#markup' => $this->t('or'),
@@ -133,7 +134,7 @@ public function buildForm(array $form, FormStateInterface $form_state, $entity_t
         '#empty_option' => $this->t('- Select an existing field -'),
       ];
 
-      $form['#attached']['drupalSettings']['existingFieldLabels'] = $this->getExistingFieldLabels(array_keys($existing_field_storage_options));
+      $form['#attached']['drupalSettings']['existingFieldLabels'] = $this->getExistingFieldLabels($existing_field_storage_options);
     }
     else {
       // Provide a placeholder form element to simplify the validation code.
@@ -288,125 +289,135 @@ protected function validateAddExisting(array $form, FormStateInterface $form_sta
    * {@inheritdoc}
    */
   public function submitForm(array &$form, FormStateInterface $form_state) {
-    $error = FALSE;
     $values = $form_state->getValues();
-    $destinations = [];
     $entity_type = $this->entityManager->getDefinition($this->entityTypeId);
+    $default_options = [
+      'entity_form_display' => ['default' => []],
+      'entity_view_display' => ['default' => []],
+    ];
+    $field_values = [
+      'entity_type' => $this->entityTypeId,
+      'bundle' => $this->bundle,
+    ];
 
-    // Create new field.
-    if ($values['new_storage_type']) {
-      $field_storage_values = [
-        'field_name' => $values['field_name'],
-        'entity_type' => $this->entityTypeId,
-        'type' => $values['new_storage_type'],
-        'translatable' => $values['translatable'],
+    // There are a few differences depending on whether we create a new field or
+    // re-use an existing one.
+    if (empty($values['new_storage_type'])) {
+      $is_new_field = FALSE;
+      $field_name = $values['existing_storage_name'];
+
+      // Get settings from existing configuration.
+      if (strpos($field_name, ':') !== FALSE) {
+        list($field_name, $existing_bundle) = explode(':', $field_name, 2);
+        $default_options
+          = $this->getExistingFieldDefaults($field_name, $existing_bundle);
+      }
+
+      $field_values += [
+        'field_name' => $field_name,
+        'label' => $values['existing_storage_label'],
       ];
-      $field_values = [
-        'field_name' => $values['field_name'],
-        'entity_type' => $this->entityTypeId,
-        'bundle' => $this->bundle,
+    }
+    else {
+      $is_new_field = TRUE;
+      $field_name = $values['field_name'];
+      $field_storage_type = $values['new_storage_type'];
+
+      // Check if we're dealing with a preconfigured field.
+      if (strpos($field_storage_type, 'field_ui:') === 0) {
+        list(, $field_type, $preset_key) = explode(':', $field_storage_type, 3);
+        $default_options = getNewFieldDefaults($field_type, $preset_key);
+      }
+      else {
+        $field_type = $field_storage_type;
+      }
+
+      $field_values += [
+        'field_name' => $field_name,
         'label' => $values['label'],
         // Field translatability should be explicitly enabled by the users.
         'translatable' => FALSE,
       ];
-      $widget_id = $formatter_id = NULL;
-
-      // Check if we're dealing with a preconfigured field.
-      if (strpos($field_storage_values['type'], 'field_ui:') !== FALSE) {
-        list(, $field_type, $option_key) = explode(':', $field_storage_values['type'], 3);
-        $field_storage_values['type'] = $field_type;
-
-        $field_type_class = $this->fieldTypePluginManager->getDefinition($field_type)['class'];
-        $field_options = $field_type_class::getPreconfiguredOptions()[$option_key];
-
-        // Merge in preconfigured field storage options.
-        if (isset($field_options['field_storage_config'])) {
-          foreach (['cardinality', 'settings'] as $key) {
-            if (isset($field_options['field_storage_config'][$key])) {
-              $field_storage_values[$key] = $field_options['field_storage_config'][$key];
-            }
-          }
-        }
-
-        // Merge in preconfigured field options.
-        if (isset($field_options['field_config'])) {
-          foreach (['required', 'settings'] as $key) {
-            if (isset($field_options['field_config'][$key])) {
-              $field_values[$key] = $field_options['field_config'][$key];
-            }
-          }
-        }
-
-        $widget_id = isset($field_options['entity_form_display']['type']) ? $field_options['entity_form_display']['type'] : NULL;
-        $formatter_id = isset($field_options['entity_view_display']['type']) ? $field_options['entity_view_display']['type'] : NULL;
-      }
 
-      // Create the field storage and field.
-      try {
-        $this->entityManager->getStorage('field_storage_config')->create($field_storage_values)->save();
-        $field = $this->entityManager->getStorage('field_config')->create($field_values);
-        $field->save();
-
-        $this->configureEntityFormDisplay($values['field_name'], $widget_id);
-        $this->configureEntityViewDisplay($values['field_name'], $formatter_id);
-
-        // Always show the field settings step, as the cardinality needs to be
-        // configured for new fields.
-        $route_parameters = [
-          'field_config' => $field->id(),
-        ] + FieldUI::getRouteBundleParameter($entity_type, $this->bundle);
-        $destinations[] = ['route_name' => "entity.field_config.{$this->entityTypeId}_storage_edit_form", 'route_parameters' => $route_parameters];
-        $destinations[] = ['route_name' => "entity.field_config.{$this->entityTypeId}_field_edit_form", 'route_parameters' => $route_parameters];
-        $destinations[] = ['route_name' => "entity.{$this->entityTypeId}.field_ui_fields", 'route_parameters' => $route_parameters];
-
-        // Store new field information for any additional submit handlers.
-        $form_state->set(['fields_added', '_add_new_field'], $values['field_name']);
-      }
-      catch (\Exception $e) {
-        $error = TRUE;
-        drupal_set_message($this->t('There was a problem creating field %label: @message', ['%label' => $values['label'], '@message' => $e->getMessage()]), 'error');
-      }
+      $field_storage_values = [
+        'field_name' => $field_name,
+        'type' => $field_type,
+        'entity_type' => $this->entityTypeId,
+        'translatable' => $values['translatable'],
+      ];
     }
 
-    // Re-use existing field.
-    if ($values['existing_storage_name']) {
-      $field_name = $values['existing_storage_name'];
+    if (isset($default_options['field_config'])) {
+      $field_values += array_intersect_key(
+        $default_options['field_config'],
+        ['required' => 0, 'settings' => 1]
+      );
+    }
 
-      try {
-        $field = $this->entityManager->getStorage('field_config')->create([
-          'field_name' => $field_name,
-          'entity_type' => $this->entityTypeId,
-          'bundle' => $this->bundle,
-          'label' => $values['existing_storage_label'],
-        ]);
-        $field->save();
+    if (isset($default_options['field_storage_config'])) {
+      $field_storage_values += array_intersect_key(
+        $default_options['field_storage_config'],
+        ['cardinality' => 0, 'settings' => 1]
+      );
+    }
 
-        $this->configureEntityFormDisplay($field_name);
-        $this->configureEntityViewDisplay($field_name);
+    try {
+      // Create the field storage.
+      if ($is_new_field) {
+        $this->entityManager->getStorage('field_storage_config')
+          ->create($field_storage_values)->save();
+      }
 
-        $route_parameters = [
-          'field_config' => $field->id(),
-        ] + FieldUI::getRouteBundleParameter($entity_type, $this->bundle);
-        $destinations[] = ['route_name' => "entity.field_config.{$this->entityTypeId}_field_edit_form", 'route_parameters' => $route_parameters];
-        $destinations[] = ['route_name' => "entity.{$this->entityTypeId}.field_ui_fields", 'route_parameters' => $route_parameters];
+      // Create the field.
+      $field = $this->entityManager->getStorage('field_config')
+        ->create($field_values);
+      $field->save();
 
-        // Store new field information for any additional submit handlers.
-        $form_state->set(['fields_added', '_add_existing_field'], $field_name);
+      // Configure the display modes.
+      if (!empty($default_options['entity_form_display'])) {
+        $this->configureEntityFormDisplay($field_name, $default_options['entity_form_display']);
       }
-      catch (\Exception $e) {
-        $error = TRUE;
-        drupal_set_message($this->t('There was a problem creating field %label: @message', ['%label' => $values['label'], '@message' => $e->getMessage()]), 'error');
+      if (!empty($default_options['entity_view_display'])) {
+        $this->configureEntityViewDisplay($field_name, $default_options['entity_view_display']);
       }
     }
-
-    if ($destinations) {
-      $destination = $this->getDestinationArray();
-      $destinations[] = $destination['destination'];
-      $form_state->setRedirectUrl(FieldUI::getNextDestination($destinations, $form_state));
+    catch (\Exception $e) {
+      drupal_set_message($this->t('There was a problem creating field %label: @message', ['%label' => $values['label'], '@message' => $e->getMessage()]), 'error');
+      return;
     }
-    elseif (!$error) {
-      drupal_set_message($this->t('Your settings have been saved.'));
+
+    // Configure next steps in the multi-part form.
+    $destinations = [];
+    $route_parameters = [
+      'field_config' => $field->id(),
+    ] + FieldUI::getRouteBundleParameter($entity_type, $this->bundle);
+    if ($is_new_field) {
+      // Always show the field settings step, as the cardinality needs to be
+      // configured for new fields.
+      $destinations[] = [
+        'route_name' => "entity.field_config.{$this->entityTypeId}_storage_edit_form",
+        'route_parameters' => $route_parameters,
+      ];
     }
+    $destinations[] = [
+      'route_name' => "entity.field_config.{$this->entityTypeId}_field_edit_form",
+      'route_parameters' => $route_parameters,
+    ];
+    $destinations[] = [
+      'route_name' => "entity.{$this->entityTypeId}.field_ui_fields",
+      'route_parameters' => $route_parameters,
+    ];
+    $destination = $this->getDestinationArray();
+    $destinations[] = $destination['destination'];
+    $form_state->setRedirectUrl(
+      FieldUI::getNextDestination($destinations, $form_state)
+    );
+
+    // Store new field information for any additional submit handlers.
+    $subkey = $is_new_field ? '_add_new_field' : '_add_existing_field';
+    $form_state->set(['fields_added', $subkey], $field_name);
+
+    drupal_set_message($this->t('Your settings have been saved.'));
   }
 
   /**
@@ -414,17 +425,19 @@ public function submitForm(array &$form, FormStateInterface $form_state) {
    *
    * @param string $field_name
    *   The field name.
-   * @param string|null $widget_id
-   *   (optional) The plugin ID of the widget. Defaults to NULL.
+   * @param array[] $settings
+   *   (optional) an array of settings, keyed by form mode. Defaults to [].
    */
-  protected function configureEntityFormDisplay($field_name, $widget_id = NULL) {
-    // Make sure the field is displayed in the 'default' form mode (using
-    // default widget and settings). It stays hidden for other form modes
-    // until it is explicitly configured.
-    $options = $widget_id ? ['type' => $widget_id] : [];
-    entity_get_form_display($this->entityTypeId, $this->bundle, 'default')
-      ->setComponent($field_name, $options)
-      ->save();
+  protected function configureEntityFormDisplay($field_name, $settings = []) {
+    // For a new field, only $mode = 'default' should be set. Use the
+    // preconfigured or default widget and settings. The field will not appear
+    // in other form modes  until it is explicitly configured. When an existing
+    // field is reused, copy the behavior for all form modes.
+    foreach ($settings as $mode => $options) {
+      entity_get_form_display($this->entityTypeId, $this->bundle, $mode)
+        ->setComponent($field_name, $options)
+        ->save();
+    }
   }
 
   /**
@@ -432,27 +445,34 @@ protected function configureEntityFormDisplay($field_name, $widget_id = NULL) {
    *
    * @param string $field_name
    *   The field name.
-   * @param string|null $formatter_id
-   *   (optional) The plugin ID of the formatter. Defaults to NULL.
+   * @param string[][] $settings
+   *   (optional) an array of settings, keyed by view mode. Only the 'type' key
+   *   of the inner array is used, and the value should be the plugin ID of a
+   *   formatter. Defaults to [].
    */
-  protected function configureEntityViewDisplay($field_name, $formatter_id = NULL) {
-    // Make sure the field is displayed in the 'default' view mode (using
-    // default formatter and settings). It stays hidden for other view
-    // modes until it is explicitly configured.
-    $options = $formatter_id ? ['type' => $formatter_id] : [];
-    entity_get_display($this->entityTypeId, $this->bundle, 'default')
-      ->setComponent($field_name, $options)
-      ->save();
+  protected function configureEntityViewDisplay($field_name, $settings = []) {
+    // For a new field, only $mode = 'default' should be set. Use the
+    // preconfigured or default formatter and settings. The field stays hidden
+    // for other view modes until it is explicitly configured. When an existing
+    // field is reused, copy the behavior for all view modes.
+    foreach ($settings as $mode => $options) {
+      entity_get_display($this->entityTypeId, $this->bundle, $mode)
+        ->setComponent($field_name, $options)
+        ->save();
+    }
   }
 
   /**
-   * Returns an array of existing field storages that can be added to a bundle.
+   * Returns an array of existing fields that can be added to a bundle.
    *
-   * @return array
-   *   An array of existing field storages keyed by name.
+   * @return string[][]
+   *   An array of existing field labels. The outer key is the label of the
+   *   field storage. The inner key is either the field storage name (indicating
+   *   default settings) or that name followed by ':' and the bundle name.
    */
-  protected function getExistingFieldStorageOptions() {
+  protected function getExistingFieldOptions() {
     $options = [];
+    $bundle_info = $this->entityManager->getBundleInfo($this->entityTypeId);
     // Load the field_storages and build the list of options.
     $field_types = $this->fieldTypePluginManager->getDefinitions();
     foreach ($this->entityManager->getFieldStorageDefinitions($this->entityTypeId) as $field_name => $field_storage) {
@@ -461,14 +481,31 @@ protected function getExistingFieldStorageOptions() {
       // - locked field storages,
       // - field storages that should not be added via user interface,
       // - field storages that already have a field in the bundle.
+      if (!($field_storage instanceof FieldStorageConfigInterface)) {
+        continue;
+      }
+      if ($field_storage->isLocked()) {
+        continue;
+      }
       $field_type = $field_storage->getType();
-      if ($field_storage instanceof FieldStorageConfigInterface
-        && !$field_storage->isLocked()
-        && empty($field_types[$field_type]['no_ui'])
-        && !in_array($this->bundle, $field_storage->getBundles(), TRUE)) {
-        $options[$field_name] = $this->t('@type: @field', [
-          '@type' => $field_types[$field_type]['label'],
-          '@field' => $field_name,
+      if (!empty($field_types[$field_type]['no_ui'])) {
+        continue;
+      }
+      $bundles = $field_storage->getBundles();
+      if (in_array($this->bundle, $bundles, TRUE)) {
+        continue;
+      }
+
+      $label = HTML::escape($this->t('@type (@field)', [
+        '@type' => $field_types[$field_type]['label'],
+        '@field' => $field_name,
+      ]));
+      $options[$label][$field_name] = $this->t('Default settings');
+      // Add an option for each bundle that has the field.
+      foreach ($bundles as $bundle) {
+        $options[$label]["$field_name:$bundle"] = $this->t('@label (@bundle)', [
+          '@label' => $bundle_info[$bundle]['label'],
+          '@bundle' => $bundle,
         ]);
       }
     }
@@ -484,13 +521,25 @@ protected function getExistingFieldStorageOptions() {
    * provide the field labels on a best-effort basis (e.g. the label of a field
    * storage without any field attached to a bundle will be the field name).
    *
-   * @param array $field_names
-   *   An array of field names.
+   * @param array[] $field_options
+   *   An array of arrays of field names. Only the keys of the inner arrays are
+   *   used. These should be of the form 'field' or 'field:bundle'. See
+   *   getExistingFieldOptions().
    *
    * @return array
    *   An array of field labels keyed by field name.
    */
-  protected function getExistingFieldLabels(array $field_names) {
+  protected function getExistingFieldLabels(array $field_options) {
+    // Extract the field storage names from the inner keys of $field_options.
+    $field_names = [];
+    foreach ($field_options as $options) {
+      $field_names = array_merge($field_names, array_unique(
+        array_map(function ($key) {
+          return preg_replace('/:.*/', '', $key);
+        }, array_keys($options))
+      ));
+    }
+
     // Get all the fields corresponding to the given field storage names and
     // this entity type.
     $field_ids = $this->entityManager->getStorage('field_config')->getQuery()
@@ -499,12 +548,14 @@ protected function getExistingFieldLabels(array $field_names) {
       ->execute();
     $fields = $this->entityManager->getStorage('field_config')->loadMultiple($field_ids);
 
-    // Go through all the fields and use the label of the first encounter.
+    // Go through all the fields. For the default (no bundle), use the label of
+    // the first encounter.
     $labels = [];
     foreach ($fields as $field) {
-      if (!isset($labels[$field->getName()])) {
-        $labels[$field->getName()] = $field->label();
-      }
+      $labels += [
+        $field->getName() => $field->label(),
+        $field->getName() . ':' . $field->getTargetBundle() => $field->label(),
+      ];
     }
 
     // For field storages without any fields attached to a bundle, the default
@@ -515,6 +566,85 @@ protected function getExistingFieldLabels(array $field_names) {
   }
 
   /**
+   * Get default options from an existing field and bundle.
+   *
+   * @param string $field_name
+   *   The machine name of the field.
+   * @param string $existing_bundle
+   *   The name of the existing bundle (not $this->bundle).
+   *
+   * @return array
+   *   An array of settings with keys 'field_config', 'entity_form_display', and
+   *   'entity_view_display'.
+   */
+  protected function getExistingFieldDefaults($field_name, $existing_bundle) {
+    // Copy field configuration.
+    $existing_field = $this->entityManager
+      ->getFieldDefinitions($this->entityTypeId, $existing_bundle)[$field_name];
+    $default_options['field_config'] = [
+      'required' => $existing_field->get('required'),
+      'settings' => $existing_field->get('settings'),
+    ];
+
+    // Copy form and view mode configuration.
+    $properties = [
+      'targetEntityType' => $this->entityTypeId,
+      'bundle' => $existing_bundle,
+    ];
+    $existing_forms = $this->entityManager
+      ->getStorage('entity_form_display')
+      ->loadByProperties($properties);
+    foreach ($existing_forms as $type => $form) {
+      if ($settings = $form->getComponent($field_name)) {
+        $default_options['entity_form_display'][$form->getMode()] = $settings;
+      }
+    }
+    $existing_views = $this->entityManager
+      ->getStorage('entity_view_display')
+      ->loadByProperties($properties);
+    foreach ($existing_views as $type => $view) {
+      if ($settings = $view->getComponent($field_name)) {
+        $default_options['entity_view_display'][$view->getMode()] = $settings;
+      }
+    }
+
+    return $default_options;
+  }
+
+  /**
+   * Get default options from preconfigured options for a new field.
+   *
+   * Get the preconfigured options for the corresponding key but nest the
+   * options for 'entity_form_display' and 'entity_view_display' one level
+   * deeper, with key 'default' (for the display mode).
+   *
+   * @param string $field_name
+   *   The machine name of the field. The field class must implement
+   *   Drupal\Core\Field\PreconfiguredFieldUiOptionsInterface,
+   * @param string $preset_key
+   *   A key in the preconfigured options array for the field.
+   *
+   * @return array
+   *   An array of settings with keys 'field_config', 'entity_form_display', and
+   *   'entity_view_display'.
+   *
+   * @see Drupal\Core\Field\PreconfiguredFieldUiOptionsInterface::getPreconfiguredOptions()
+   */
+  protected function getNewFieldDefaults($field_name, $preset_key) {
+    $field_type_class = $this->fieldTypePluginManager
+      ->getDefinition($field_name)['class'];
+    $default_options = $field_type_class::getPreconfiguredOptions()[$preset_key];
+    // Preconfigured options only apply to the default display modes.
+    foreach (['entity_form_display', 'entity_view_display'] as $key) {
+      if (isset($default_options[$key])) {
+        $default_options[$key] = ['default' => $default_options[$key]];
+      }
+    }
+
+    return $default_options;
+  }
+
+  /**
    * Checks if a field machine name is taken.
    *
    * @param string $value
diff --git a/core/modules/field_ui/src/Tests/ManageFieldsTest.php b/core/modules/field_ui/src/Tests/ManageFieldsTest.php
index d08ab03ba4..6d5bde9539 100644
--- a/core/modules/field_ui/src/Tests/ManageFieldsTest.php
+++ b/core/modules/field_ui/src/Tests/ManageFieldsTest.php
@@ -750,6 +750,19 @@ public function testPreconfiguredFields() {
     $this->assertEqual($form_display->getComponent('field_test_custom_options')['type'], 'test_field_widget_multiple');
     $view_display = entity_get_display('node', 'article', 'default');
     $this->assertEqual($view_display->getComponent('field_test_custom_options')['type'], 'field_test_multiple');
+
+    // Add the preconfigured field to a second content type.
+    $this->fieldUIAddExistingField("admin/structure/types/manage/page", 'test_custom_options', 'Test label');
+
+    // Check that the preconfigured options are applied.
+    $field = FieldConfig::loadByName('node', 'page', 'field_test_custom_options');
+    $this->assertTrue($field->isRequired());
+    $this->assertEqual($field->getSetting('test_field_setting'), 'preconfigured_field_setting');
+
+    $form_display = entity_get_form_display('node', 'page', 'default');
+    $this->assertEqual($form_display->getComponent('field_test_custom_options')['type'], 'test_field_widget_multiple');
+    $view_display = entity_get_display('node', 'page', 'default');
+    $this->assertEqual($view_display->getComponent('field_test_custom_options')['type'], 'field_test_multiple');
   }
 
   /**