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 e1f278796e..cb3e22ec44 100644
--- a/core/modules/field_ui/src/Form/FieldStorageAddForm.php
+++ b/core/modules/field_ui/src/Form/FieldStorageAddForm.php
@@ -288,125 +288,136 @@ 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.
+      $default_options = $this->getExistingFieldDefaults($field_name);
+
+      $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 = $this->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'], [
+          'description' => 0,
+          'settings' => 0,
+          'required' => 0,
+          'default_value' => 0,
+          'default_value_callback' => 0,
+        ]
+      );
+    }
 
-      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,30 @@ 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, array $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.
+    $enabled_modes = [];
+    $form_modes = $this->entityManager->getFormModes('node');
+    foreach ($settings as $mode => $options) {
+      $form = entity_get_form_display($this->entityTypeId, $this->bundle, $mode);
+      if (!$form->status()) {
+        $form->set('status', TRUE);
+        $enabled_modes[] = $form_modes[$mode]['label'];
+      }
+      $form->setComponent($field_name, $options)->save();
+    }
+
+    if ($enabled_modes) {
+      drupal_set_message($this->t('The following form mode(s) were enabled: %enabled_modes', [
+        '%enabled_modes' => implode(', ', $enabled_modes),
+      ]));
+    }
   }
 
   /**
@@ -432,17 +456,32 @@ 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, array $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.
+    $enabled_modes = [];
+    $view_modes = $this->entityManager->getViewModes('node');
+    foreach ($settings as $mode => $options) {
+      $view = entity_get_display($this->entityTypeId, $this->bundle, $mode);
+      if (!$view->status()) {
+        $view->set('status', TRUE);
+        $enabled_modes[] = $view_modes[$mode]['label'];
+      }
+      $view->setComponent($field_name, $options)->save();
+    }
+
+    if ($enabled_modes) {
+      drupal_set_message($this->t('The following view mode(s) were enabled: %enabled_modes', [
+        '%enabled_modes' => implode(', ', $enabled_modes),
+      ]));
+    }
   }
 
   /**
@@ -514,6 +553,115 @@ protected function getExistingFieldLabels(array $field_names) {
     return $labels;
   }
 
+  /**
+   * Get default options from an existing field and bundle.
+   *
+   * @param string $field_name
+   *   The machine name of the field.
+   * @param string $existing_bundle
+   *   (optional) 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' if these are defined for the existing field. If the
+   *   field is not defined for the specified bundle (or for any bundle if
+   *   $existing_bundle is omitted) then return an empty array.
+   */
+  protected function getExistingFieldDefaults($field_name, $existing_bundle = '') {
+    $default_options = [];
+    $field_map = $this->entityManager->getFieldMap();
+    if ($existing_bundle) {
+      // Validate that $existing_bundle is different from $this->bundle and that
+      // the field is defined for the supplied bundle.
+      if ($existing_bundle == $this->bundle) {
+        return [];
+      }
+      if (empty($field_map[$this->entityTypeId][$field_name]['bundles'][$existing_bundle])) {
+        return [];
+      }
+    }
+    else {
+      // If $existing_bundle is not supplied, then find a suitable candidate.
+      // @todo Consistently choose the bundle. Oldest? Newest?
+      if (empty($field_map[$this->entityTypeId][$field_name]['bundles'])) {
+        return [];
+      }
+      $bundles = $field_map[$this->entityTypeId][$field_name]['bundles'];
+      $existing_bundle = reset($bundles);
+    }
+
+    // Copy field configuration.
+    $existing_field = $this->entityManager
+      ->getFieldDefinitions($this->entityTypeId, $existing_bundle)[$field_name];
+    $default_options['field_config'] = [
+      'description' => $existing_field->get('description'),
+      'settings' => $existing_field->get('settings'),
+      'required' => $existing_field->get('required'),
+      'default_value' => $existing_field->get('default_value'),
+      'default_value_callback' => $existing_field->get('default_value_callback'),
+    ];
+
+    // 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]];
+      }
+      else {
+        $default_options[$key] = ['default' => []];
+      }
+    }
+
+    return $default_options;
+  }
+
   /**
    * Checks if a field machine name is taken.
    *
diff --git a/core/modules/field_ui/src/Tests/ManageFieldsTest.php b/core/modules/field_ui/src/Tests/ManageFieldsTest.php
index d08ab03ba4..1900bd0a8a 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", 'field_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');
   }
 
   /**