diff --git a/org.eclipse.scout.rt.client.test/src/org/eclipse/scout/rt/client/ui/form/fields/ReplaceFieldTest.java b/org.eclipse.scout.rt.client.test/src/org/eclipse/scout/rt/client/ui/form/fields/ReplaceFieldTest.java
index f8274ac..8992776 100644
--- a/org.eclipse.scout.rt.client.test/src/org/eclipse/scout/rt/client/ui/form/fields/ReplaceFieldTest.java
+++ b/org.eclipse.scout.rt.client.test/src/org/eclipse/scout/rt/client/ui/form/fields/ReplaceFieldTest.java
@@ -127,6 +127,13 @@
     assertSame(AbstractTemplateBox.SecondTemplateField.class, form.getTemplate2Box().getSecondTemplateField().getClass());
   }
 
+  @Test
+  public void testNestedReplace() throws Exception {
+    ExampleExForm form = new ExampleExForm();
+    assertNotNull(form.getTextField());
+    assertSame(ExampleExForm.DetailExBox.TextExField.class, form.getTextField().getClass());
+  }
+
   public static class BaseField extends AbstractStringField {
   }
 
@@ -309,4 +316,42 @@
       }
     }
   }
+
+  public static class ExampleForm extends AbstractForm {
+
+    public ExampleForm() throws ProcessingException {
+      super();
+    }
+
+    public MainBox.DetailBox.TextField getTextField() {
+      return getFieldByClass(MainBox.DetailBox.TextField.class);
+    }
+
+    @Order(10)
+    public class MainBox extends AbstractGroupBox {
+      @Order(10)
+      public class DetailBox extends AbstractGroupBox {
+        @Order(10)
+        public class TextField extends AbstractStringField {
+        }
+      }
+    }
+  }
+
+  public static class ExampleExForm extends ExampleForm {
+    public ExampleExForm() throws ProcessingException {
+      super();
+    }
+
+    @Replace
+    public class DetailExBox extends MainBox.DetailBox {
+      public DetailExBox(ExampleForm.MainBox container) {
+        container.super();
+      }
+
+      @Replace
+      public class TextExField extends TextField {
+      }
+    }
+  }
 }
diff --git a/org.eclipse.scout.rt.client/src/org/eclipse/scout/rt/client/ui/form/fields/AbstractCompositeField.java b/org.eclipse.scout.rt.client/src/org/eclipse/scout/rt/client/ui/form/fields/AbstractCompositeField.java
index 1cc5823..65572a3 100644
--- a/org.eclipse.scout.rt.client/src/org/eclipse/scout/rt/client/ui/form/fields/AbstractCompositeField.java
+++ b/org.eclipse.scout.rt.client/src/org/eclipse/scout/rt/client/ui/form/fields/AbstractCompositeField.java
@@ -12,12 +12,15 @@
 
 import java.beans.PropertyChangeEvent;
 import java.beans.PropertyChangeListener;
+import java.lang.reflect.Modifier;
 import java.util.ArrayList;
 import java.util.Arrays;
+import java.util.HashMap;
 import java.util.List;
 import java.util.Map;
 
 import org.eclipse.scout.commons.CollectionUtility;
+import org.eclipse.scout.commons.CompareUtility;
 import org.eclipse.scout.commons.ConfigurationUtility;
 import org.eclipse.scout.commons.annotations.ClassId;
 import org.eclipse.scout.commons.annotations.InjectFieldTo;
@@ -30,6 +33,10 @@
 import org.eclipse.scout.rt.client.ui.form.IForm;
 import org.eclipse.scout.rt.client.ui.form.IFormFieldVisitor;
 import org.eclipse.scout.rt.client.ui.form.fields.groupbox.AbstractGroupBox;
+import org.eclipse.scout.rt.client.ui.form.fields.sequencebox.AbstractSequenceBox;
+import org.eclipse.scout.rt.client.ui.form.fields.snapbox.AbstractSnapBox;
+import org.eclipse.scout.rt.client.ui.form.fields.splitbox.AbstractSplitBox;
+import org.eclipse.scout.rt.client.ui.form.fields.tabbox.AbstractTabBox;
 import org.eclipse.scout.rt.client.ui.form.fields.wrappedform.IWrappedFormField;
 import org.eclipse.scout.rt.shared.services.common.exceptionhandler.IExceptionHandlerService;
 import org.eclipse.scout.service.SERVICES;
@@ -150,12 +157,78 @@
   @Override
   public void setFormInternal(IForm form) {
     super.setFormInternal(form);
+    if (this == form.getRootGroupBox() && form instanceof AbstractForm) {
+      // this is the root group box. Publish replacement map to form and keep local map for better performance (see getReplacingFieldClass)
+      ((AbstractForm) form).registerFormFieldReplacementsInternal(m_formFieldReplacements);
+    }
     for (IFormField field : m_fields) {
       field.setFormInternal(form);
     }
   }
 
   @Override
+  public void setParentFieldInternal(ICompositeField parentField) {
+    super.setParentFieldInternal(parentField);
+    if (!(parentField instanceof AbstractCompositeField)) {
+      return;
+    }
+
+    // check if this is a template field box
+    if (isTemplateField()) {
+      // do not publish replacement map for template field boxes
+      return;
+    }
+
+    // publish replacement map to parent AbstractCompositeField and keep local map for better performance (see getReplacingFieldClass)
+    ((AbstractCompositeField) parentField).registerFormFieldReplacements(m_formFieldReplacements);
+  }
+
+  /**
+   * Returns <code>true</code> if this field is a template group box, i.e. an abstract box class containing
+   * other {@link IFormField}s.
+   * <p/>
+   * This default implementation checks the path of super classes, starting by the most specific one and stopping by
+   * this class or one of its well known direct sub classes (i.e {@link AbstractGroupBox}, {@link AbstractSequenceBox},
+   * {@link AbstractSnapBox}, {@link AbstractSplitBox} and {@link AbstractTabBox}). If there exists an abstract class
+   * containing {@link IFormField}, this method returns <code>true</code>. Subclasses may override this default
+   * behavior.
+   * 
+   * @since 4.0.1
+   */
+  protected boolean isTemplateField() {
+    Class<?> c = getClass();
+    while (c.getSuperclass() != null) {
+      c = c.getSuperclass();
+
+      // non-abstract classes are not considered as template
+      if (!Modifier.isAbstract(c.getModifiers())) {
+        continue;
+      }
+
+      // quick check for well known Scout classes
+      if (CompareUtility.isOneOf(c,
+          AbstractCompositeField.class,
+          AbstractGroupBox.class,
+          AbstractSequenceBox.class,
+          AbstractSnapBox.class,
+          AbstractSplitBox.class,
+          AbstractTabBox.class)) {
+        return false;
+      }
+
+      // class is only a template if it contains fields
+      for (Class<?> innerClass : c.getDeclaredClasses()) {
+        int m = innerClass.getModifiers();
+        if (Modifier.isPublic(m) && !Modifier.isAbstract(m) && IFormField.class.isAssignableFrom(innerClass)) {
+          return true;
+        }
+      }
+    }
+
+    return false;
+  }
+
+  @Override
   public int getFieldIndex(IFormField f) {
     return m_fields.indexOf(f);
   }
@@ -217,6 +290,23 @@
   }
 
   /**
+   * Registers the given form field replacements on this composite field.
+   * 
+   * @param replacements
+   *          Map having old field classes as key and replacing field classes as values.
+   * @since 4.0.1
+   */
+  private void registerFormFieldReplacements(Map<Class<?>, Class<? extends IFormField>> replacements) {
+    if (replacements == null || replacements.isEmpty()) {
+      return;
+    }
+    if (m_formFieldReplacements == null) {
+      m_formFieldReplacements = new HashMap<Class<?>, Class<? extends IFormField>>();
+    }
+    m_formFieldReplacements.putAll(replacements);
+  }
+
+  /**
    * Checks whether the form field with the given class has been replaced by another form field. If so, the replacing
    * form field's class is returned. Otherwise the given class itself.
    * 
@@ -246,7 +336,22 @@
         }
       }
     }
-    // 3. field is not replaced
+    // 3. check parent field replacements (used for templates only. It is less common and therefore checked after global replacements)
+    ICompositeField parentField = getParentField();
+    while (parentField != null) {
+      if (parentField instanceof AbstractCompositeField) {
+        Map<Class<?>, Class<? extends IFormField>> parentReplacements = ((AbstractCompositeField) parentField).m_formFieldReplacements;
+        if (parentReplacements != null) {
+          @SuppressWarnings("unchecked")
+          Class<? extends T> replacementFieldClass = (Class<? extends T>) parentReplacements.get(c);
+          if (replacementFieldClass != null) {
+            return replacementFieldClass;
+          }
+        }
+      }
+      parentField = parentField.getParentField();
+    }
+    // 4. field is not replaced
     return c;
   }