diff --git a/src/ng/directive/ngOptions.js b/src/ng/directive/ngOptions.js
index e82d5e49813a..eecc6ccaa8c6 100644
--- a/src/ng/directive/ngOptions.js
+++ b/src/ng/directive/ngOptions.js
@@ -449,12 +449,12 @@ var ngOptionsDirective = ['$compile', '$document', '$parse', function($compile,
       if (!multiple) {
 
         selectCtrl.writeValue = function writeNgOptionsValue(value) {
-          var selectedOption = options.selectValueMap[selectElement.val()];
+          var selectedOption = selectElement[0].options[selectElement[0].selectedIndex];
           var option = options.getOptionFromViewValue(value);
 
           // Make sure to remove the selected attribute from the previously selected option
           // Otherwise, screen readers might get confused
-          if (selectedOption) selectedOption.element.removeAttribute('selected');
+          if (selectedOption) selectedOption.removeAttribute('selected');
 
           if (option) {
             // Don't update the option when it is already selected.
@@ -464,7 +464,6 @@ var ngOptionsDirective = ['$compile', '$document', '$parse', function($compile,
 
             if (selectElement[0].value !== option.selectValue) {
               selectCtrl.removeUnknownOption();
-              selectCtrl.unselectEmptyOption();
 
               selectElement[0].value = option.selectValue;
               option.element.selected = true;
@@ -472,14 +471,7 @@ var ngOptionsDirective = ['$compile', '$document', '$parse', function($compile,
 
             option.element.setAttribute('selected', 'selected');
           } else {
-
-            if (providedEmptyOption) {
-              selectCtrl.selectEmptyOption();
-            } else if (selectCtrl.unknownOption.parent().length) {
-              selectCtrl.updateUnknownOption(value);
-            } else {
-              selectCtrl.renderUnknownOption(value);
-            }
+            selectCtrl.selectUnknownOrEmptyOption(value);
           }
         };
 
@@ -657,7 +649,12 @@ var ngOptionsDirective = ['$compile', '$document', '$parse', function($compile,
 
         // Ensure that the empty option is always there if it was explicitly provided
         if (providedEmptyOption) {
-          selectElement.prepend(selectCtrl.emptyOption);
+
+          if (selectCtrl.unknownOption.parent().length) {
+            selectCtrl.unknownOption.after(selectCtrl.emptyOption);
+          } else {
+            selectElement.prepend(selectCtrl.emptyOption);
+          }
         }
 
         options.items.forEach(function addOption(option) {
@@ -704,7 +701,6 @@ var ngOptionsDirective = ['$compile', '$document', '$parse', function($compile,
             ngModelCtrl.$render();
           }
         }
-
       }
   }
 
diff --git a/src/ng/directive/select.js b/src/ng/directive/select.js
index dc828764d3da..d8a19605f96d 100644
--- a/src/ng/directive/select.js
+++ b/src/ng/directive/select.js
@@ -44,11 +44,13 @@ var SelectController =
   // to create it in <select> and IE barfs otherwise.
   self.unknownOption = jqLite(window.document.createElement('option'));
 
-  // The empty option is an option with the value '' that te application developer can
-  // provide inside the select. When the model changes to a value that doesn't match an option,
-  // it is selected - so if an empty option is provided, no unknown option is generated.
-  // However, the empty option is not removed when the model matches an option. It is always selectable
-  // and indicates that a "null" selection has been made.
+  // The empty option is an option with the value '' that the application developer can
+  // provide inside the select. It is always selectable and indicates that a "null" selection has
+  // been made by the user.
+  // If the select has an empty option, and the model of the select is set to "undefined" or "null",
+  // the empty option is selected.
+  // If the model is set to a different unmatched value, the unknown option is rendered and
+  // selected, i.e both are present, because a "null" selection and an unknown value are different.
   self.hasEmptyOption = false;
   self.emptyOption = undefined;
 
@@ -84,7 +86,7 @@ var SelectController =
 
   self.unselectEmptyOption = function() {
     if (self.hasEmptyOption) {
-      self.emptyOption.removeAttr('selected');
+      setOptionSelectedStatus(self.emptyOption, false);
     }
   };
 
@@ -126,14 +128,7 @@ var SelectController =
       var selectedOption = $element[0].options[$element[0].selectedIndex];
       setOptionSelectedStatus(jqLite(selectedOption), true);
     } else {
-      if (value == null && self.emptyOption) {
-        self.removeUnknownOption();
-        self.selectEmptyOption();
-      } else if (self.unknownOption.parent().length) {
-        self.updateUnknownOption(value);
-      } else {
-        self.renderUnknownOption(value);
-      }
+      self.selectUnknownOrEmptyOption(value);
     }
   };
 
@@ -176,6 +171,16 @@ var SelectController =
     return !!optionsMap.get(value);
   };
 
+  self.selectUnknownOrEmptyOption = function(value) {
+    if (value == null && self.emptyOption) {
+      self.removeUnknownOption();
+      self.selectEmptyOption();
+    } else if (self.unknownOption.parent().length) {
+      self.updateUnknownOption(value);
+    } else {
+      self.renderUnknownOption(value);
+    }
+  };
 
   var renderScheduled = false;
   function scheduleRender() {
diff --git a/test/helpers/matchers.js b/test/helpers/matchers.js
index 032f6760adc3..ac297609e579 100644
--- a/test/helpers/matchers.js
+++ b/test/helpers/matchers.js
@@ -365,13 +365,15 @@ beforeEach(function() {
       return {
         compare: function(actual) {
           var errors = [];
+          var optionVal = toJson(actual.value);
+
           if (actual.selected === null || typeof actual.selected === 'undefined' || actual.selected === false) {
-            errors.push('Expected option property "selected" to be truthy');
+            errors.push('Expected option with value ' + optionVal + ' to have property "selected" set to truthy');
           }
 
           // Support: IE 9 only
           if (msie !== 9 && actual.hasAttribute('selected') === false) {
-            errors.push('Expected option to have attribute "selected"');
+            errors.push('Expected option with value ' + optionVal + ' to have attribute "selected"');
           }
 
           var result = {
@@ -383,13 +385,15 @@ beforeEach(function() {
         },
         negativeCompare: function(actual) {
           var errors = [];
+          var optionVal = toJson(actual.value);
+
           if (actual.selected) {
-            errors.push('Expected option property "selected" to be falsy');
+            errors.push('Expected option with value ' + optionVal + ' property "selected" to be falsy');
           }
 
           // Support: IE 9 only
           if (msie !== 9 && actual.hasAttribute('selected')) {
-            errors.push('Expected option not to have attribute "selected"');
+            errors.push('Expected option with value ' + optionVal + ' not to have attribute "selected"');
           }
 
           var result = {
@@ -400,6 +404,27 @@ beforeEach(function() {
           return result;
         }
       };
+    },
+    toEqualSelect: function() {
+      return {
+        compare: function(actual, expected) {
+          var actualValues = [],
+              expectedValues = [].slice.call(arguments, 1);
+
+          forEach(actual.find('option'), function(option) {
+            actualValues.push(option.selected ? [option.value] : option.value);
+          });
+
+          var message = function() {
+            return 'Expected ' + toJson(actualValues) + ' to equal ' + toJson(expectedValues) + '.';
+          };
+
+          return {
+            pass: equals(expectedValues, actualValues),
+            message: message
+          };
+        }
+      };
     }
   });
 });
diff --git a/test/ng/directive/ngOptionsSpec.js b/test/ng/directive/ngOptionsSpec.js
index 7a3c4ba492bf..8e0a6f8e8fcd 100644
--- a/test/ng/directive/ngOptionsSpec.js
+++ b/test/ng/directive/ngOptionsSpec.js
@@ -2,12 +2,13 @@
 
 describe('ngOptions', function() {
 
-  var scope, formElement, element, $compile, linkLog;
+  var scope, formElement, element, $compile, linkLog, ngModelCtrl;
 
   function compile(html) {
     formElement = jqLite('<form name="form">' + html + '</form>');
     element = formElement.find('select');
     $compile(formElement)(scope);
+    ngModelCtrl = element.controller('ngModel');
     scope.$apply();
   }
 
@@ -181,6 +182,7 @@ describe('ngOptions', function() {
   afterEach(function() {
     scope.$destroy(); //disables unknown option work during destruction
     dealoc(formElement);
+    ngModelCtrl = null;
   });
 
   function createSelect(attrs, blank, unknown) {
@@ -771,12 +773,32 @@ describe('ngOptions', function() {
     expect(options[1]).not.toBeMarkedAsSelected();
     expect(options[2]).toBeMarkedAsSelected();
 
-    scope.selected = 'no match';
+    // This will select the empty option
+    scope.selected = null;
     scope.$digest();
 
     expect(options[0]).toBeMarkedAsSelected();
     expect(options[1]).not.toBeMarkedAsSelected();
     expect(options[2]).not.toBeMarkedAsSelected();
+
+    // This will add and select the unknown option
+    scope.selected = 'unmatched value';
+    scope.$digest();
+    options = element.find('option');
+
+    expect(options[0]).toBeMarkedAsSelected();
+    expect(options[1]).not.toBeMarkedAsSelected();
+    expect(options[2]).not.toBeMarkedAsSelected();
+    expect(options[3]).not.toBeMarkedAsSelected();
+
+    // Back to matched value
+    scope.selected = scope.values[1];
+    scope.$digest();
+    options = element.find('option');
+
+    expect(options[0]).not.toBeMarkedAsSelected();
+    expect(options[1]).not.toBeMarkedAsSelected();
+    expect(options[2]).toBeMarkedAsSelected();
   });
 
   describe('disableWhen expression', function() {
@@ -2193,6 +2215,20 @@ describe('ngOptions', function() {
     });
 
 
+  it('should insert and select temporary unknown option when no options-model match, empty ' +
+        'option is present and model is defined', function() {
+      scope.selected = 'C';
+      scope.values = [{name: 'A'}, {name: 'B'}];
+      createSingleSelect(true);
+
+      expect(element).toEqualSelect(['?'], '', 'object:3', 'object:4');
+
+      scope.$apply('selected = values[1]');
+
+      expect(element).toEqualSelect('', 'object:3', ['object:4']);
+    });
+
+
     it('should select correct input if previously selected option was "?"', function() {
       createSingleSelect();
 
@@ -2212,6 +2248,19 @@ describe('ngOptions', function() {
     });
 
 
+    it('should remove unknown option when empty option exists and model is undefined', function() {
+      scope.selected = 'C';
+      scope.values = [{name: 'A'}, {name: 'B'}];
+      createSingleSelect(true);
+
+      expect(element).toEqualSelect(['?'], '', 'object:3', 'object:4');
+
+      scope.selected = undefined;
+      scope.$digest();
+
+      expect(element).toEqualSelect([''], 'object:3', 'object:4');
+    });
+
     it('should use exact same values as values in scope with one-time bindings', function() {
       scope.values = [{name: 'A'}, {name: 'B'}];
       scope.selected = scope.values[0];
@@ -2925,42 +2974,68 @@ describe('ngOptions', function() {
   });
 
 
-  describe('ngRequired', function() {
+  describe('required state', function() {
 
-    it('should allow bindings on ngRequired', function() {
+    it('should set the error if the empty option is selected', function() {
+      createSelect({
+        'ng-model': 'selection',
+        'ng-options': 'item for item in values',
+        'required': ''
+      }, true);
+
+      scope.$apply(function() {
+        scope.values = ['a', 'b'];
+        scope.selection = scope.values[0];
+      });
+      expect(element).toBeValid();
+      expect(ngModelCtrl.$error.required).toBeFalsy();
+
+      var options = element.find('option');
+
+      // view -> model
+      browserTrigger(options[0], 'click');
+      expect(element).toBeInvalid();
+      expect(ngModelCtrl.$error.required).toBeTruthy();
+
+      browserTrigger(options[1], 'click');
+      expect(element).toBeValid();
+      expect(ngModelCtrl.$error.required).toBeFalsy();
+
+      // model -> view
+      scope.$apply('selection = null');
+      expect(options[0]).toBeMarkedAsSelected();
+      expect(element).toBeInvalid();
+      expect(ngModelCtrl.$error.required).toBeTruthy();
+    });
+
+
+    it('should validate with empty option and bound ngRequired', function() {
       createSelect({
         'ng-model': 'value',
         'ng-options': 'item.name for item in values',
         'ng-required': 'required'
       }, true);
 
-
       scope.$apply(function() {
         scope.values = [{name: 'A', id: 1}, {name: 'B', id: 2}];
         scope.required = false;
       });
 
-      element.val('');
-      browserTrigger(element, 'change');
+      var options = element.find('option');
+
+      browserTrigger(options[0], 'click');
       expect(element).toBeValid();
 
-      scope.$apply(function() {
-        scope.required = true;
-      });
+      scope.$apply('required = true');
       expect(element).toBeInvalid();
 
-      scope.$apply(function() {
-        scope.value = scope.values[0];
-      });
+      scope.$apply('value = values[0]');
       expect(element).toBeValid();
 
-      element.val('');
-      browserTrigger(element, 'change');
+      browserTrigger(options[0], 'click');
       expect(element).toBeInvalid();
 
-      scope.$apply(function() {
-        scope.required = false;
-      });
+      scope.$apply('required = false');
       expect(element).toBeValid();
     });
 
@@ -2989,6 +3064,43 @@ describe('ngOptions', function() {
     });
 
 
+    it('should NOT set the error if the empty option is present but required attribute is not',
+      function() {
+        scope.$apply(function() {
+          scope.values = ['a', 'b'];
+        });
+
+        createSingleSelect();
+
+        expect(element).toBeValid();
+        expect(element).toBePristine();
+        expect(ngModelCtrl.$error.required).toBeFalsy();
+      }
+    );
+
+
+    it('should NOT set the error if the unknown option is selected', function() {
+      createSelect({
+        'ng-model': 'selection',
+        'ng-options': 'item for item in values',
+        'required': ''
+      });
+
+      scope.$apply(function() {
+        scope.values = ['a', 'b'];
+        scope.selection = 'a';
+      });
+
+      expect(element).toBeValid();
+      expect(ngModelCtrl.$error.required).toBeFalsy();
+
+      scope.$apply('selection = "c"');
+      expect(element).toEqualSelect(['?'], 'string:a', 'string:b');
+      expect(element).toBeValid();
+      expect(ngModelCtrl.$error.required).toBeFalsy();
+    });
+
+
     it('should allow falsy values as values', function() {
       createSelect({
         'ng-model': 'value',
@@ -3009,6 +3121,34 @@ describe('ngOptions', function() {
       expect(element).toBeValid();
       expect(scope.value).toBe(false);
     });
+
+
+    it('should validate after option list was updated', function() {
+      createSelect({
+        'ng-model': 'selection',
+        'ng-options': 'item for item in values',
+        'required': ''
+      }, true);
+
+      scope.$apply(function() {
+        scope.values = ['A', 'B'];
+        scope.selection = scope.values[0];
+      });
+
+      expect(element).toEqualSelect('', ['string:A'], 'string:B');
+      expect(element).toBeValid();
+      expect(ngModelCtrl.$error.required).toBeFalsy();
+
+      scope.$apply(function() {
+        scope.values = ['C', 'D'];
+      });
+
+      expect(element).toEqualSelect([''], 'string:C', 'string:D');
+      expect(element).toBeInvalid();
+      expect(ngModelCtrl.$error.required).toBeTruthy();
+      // ngModel sets undefined for invalid values
+      expect(scope.selection).toBeUndefined();
+    });
   });
 
   describe('required and empty option', function() {
diff --git a/test/ng/directive/selectSpec.js b/test/ng/directive/selectSpec.js
index 975e4b594d77..582338c72096 100644
--- a/test/ng/directive/selectSpec.js
+++ b/test/ng/directive/selectSpec.js
@@ -7,6 +7,7 @@ describe('select', function() {
     formElement = jqLite('<form name="form">' + html + '</form>');
     element = formElement.find('select');
     $compile(formElement)(scope);
+    ngModelCtrl = element.controller('ngModel');
     scope.$digest();
   }
 
@@ -79,33 +80,12 @@ describe('select', function() {
   afterEach(function() {
     scope.$destroy(); //disables unknown option work during destruction
     dealoc(formElement);
+    ngModelCtrl = null;
   });
 
 
   beforeEach(function() {
     jasmine.addMatchers({
-      toEqualSelect: function() {
-        return {
-          compare: function(actual, expected) {
-            var actualValues = [],
-                expectedValues = [].slice.call(arguments, 1);
-
-            forEach(actual.find('option'), function(option) {
-              actualValues.push(option.selected ? [option.value] : option.value);
-            });
-
-            var message = function() {
-              return 'Expected ' + toJson(actualValues) + ' to equal ' + toJson(expectedValues) + '.';
-            };
-
-            return {
-              pass: equals(expectedValues, actualValues),
-              message: message
-            };
-          }
-        };
-      },
-
       toEqualSelectWithOptions: function() {
         return {
           compare: function(actual, expected) {
@@ -190,54 +170,108 @@ describe('select', function() {
     });
 
 
-    it('should require', function() {
-      compile(
-        '<select name="select" ng-model="selection" required ng-change="change()">' +
-          '<option value=""></option>' +
-          '<option value="c">C</option>' +
-        '</select>');
+    describe('required state', function() {
 
-      scope.change = function() {
-        scope.log += 'change;';
-      };
+      it('should set the error if the empty option is selected', function() {
+        compile(
+          '<select name="select" ng-model="selection" required>' +
+            '<option value=""></option>' +
+            '<option value="a">A</option>' +
+            '<option value="b">B</option>' +
+          '</select>');
 
-      scope.$apply(function() {
-        scope.log = '';
-        scope.selection = 'c';
+        scope.$apply(function() {
+          scope.selection = 'a';
+        });
+
+        expect(element).toBeValid();
+        expect(ngModelCtrl.$error.required).toBeFalsy();
+
+        var options = element.find('option');
+
+        // view -> model
+        browserTrigger(options[0], 'click');
+        expect(element).toBeInvalid();
+        expect(ngModelCtrl.$error.required).toBeTruthy();
+
+        browserTrigger(options[1], 'click');
+        expect(element).toBeValid();
+        expect(ngModelCtrl.$error.required).toBeFalsy();
+
+        // model -> view
+        scope.$apply('selection = null');
+        options = element.find('option');
+        expect(options[0]).toBeMarkedAsSelected();
+        expect(element).toBeInvalid();
+        expect(ngModelCtrl.$error.required).toBeTruthy();
       });
 
-      expect(scope.form.select.$error.required).toBeFalsy();
-      expect(element).toBeValid();
-      expect(element).toBePristine();
 
-      scope.$apply(function() {
-        scope.selection = '';
+      it('should validate with empty option and bound ngRequired', function() {
+        compile(
+          '<select name="select" ng-model="selection" ng-required="required">' +
+            '<option value=""></option>' +
+            '<option value="a">A</option>' +
+            '<option value="b">B</option>' +
+          '</select>');
+
+        scope.$apply(function() {
+          scope.required = false;
+        });
+
+        var options = element.find('option');
+
+        browserTrigger(options[0], 'click');
+        expect(element).toBeValid();
+
+        scope.$apply('required = true');
+        expect(element).toBeInvalid();
+
+        scope.$apply('selection = "a"');
+        expect(element).toBeValid();
+        expect(element).toEqualSelect('', ['a'], 'b');
+
+        browserTrigger(options[0], 'click');
+        expect(element).toBeInvalid();
+
+        scope.$apply('required = false');
+        expect(element).toBeValid();
       });
 
-      expect(scope.form.select.$error.required).toBeTruthy();
-      expect(element).toBeInvalid();
-      expect(element).toBePristine();
-      expect(scope.log).toEqual('');
 
-      element[0].value = 'c';
-      browserTrigger(element, 'change');
-      expect(element).toBeValid();
-      expect(element).toBeDirty();
-      expect(scope.log).toEqual('change;');
-    });
+      it('should not be invalid if no required attribute is present', function() {
+        compile(
+          '<select name="select" ng-model="selection">' +
+            '<option value=""></option>' +
+            '<option value="c">C</option>' +
+          '</select>');
 
+        expect(element).toBeValid();
+        expect(element).toBePristine();
+      });
 
-    it('should not be invalid if no require', function() {
-      compile(
-        '<select name="select" ng-model="selection">' +
-          '<option value=""></option>' +
-          '<option value="c">C</option>' +
-        '</select>');
 
-      expect(element).toBeValid();
-      expect(element).toBePristine();
-    });
+      it('should NOT set the error if the unknown option is selected', function() {
+        compile(
+          '<select name="select" ng-model="selection" required>' +
+            '<option value="a">A</option>' +
+            '<option value="b">B</option>' +
+          '</select>');
+
+        scope.$apply(function() {
+          scope.selection = 'a';
+        });
+
+        expect(element).toBeValid();
+        expect(ngModelCtrl.$error.required).toBeFalsy();
 
+        scope.$apply('selection = "c"');
+        expect(element).toEqualSelect([unknownValue('c')], 'a', 'b');
+        expect(element).toBeValid();
+        expect(ngModelCtrl.$error.required).toBeFalsy();
+      });
+
+    });
 
     it('should work with repeated value options', function() {
       scope.robots = ['c3p0', 'r2d2'];
@@ -340,6 +374,7 @@ describe('select', function() {
 
     it('should remove the "selected" attribute from the previous option when the model changes', function() {
       compile('<select name="select" ng-model="selected">' +
+        '<option value="">--empty--</option>' +
         '<option value="a">A</option>' +
         '<option value="b">B</option>' +
       '</select>');
@@ -355,24 +390,45 @@ describe('select', function() {
       scope.$digest();
 
       options = element.find('option');
-      expect(options.length).toBe(2);
-      expect(options[0]).toBeMarkedAsSelected();
-      expect(options[1]).not.toBeMarkedAsSelected();
+      expect(options.length).toBe(3);
+      expect(options[0]).not.toBeMarkedAsSelected();
+      expect(options[1]).toBeMarkedAsSelected();
+      expect(options[2]).not.toBeMarkedAsSelected();
 
       scope.selected = 'b';
       scope.$digest();
 
       options = element.find('option');
       expect(options[0]).not.toBeMarkedAsSelected();
-      expect(options[1]).toBeMarkedAsSelected();
+      expect(options[1]).not.toBeMarkedAsSelected();
+      expect(options[2]).toBeMarkedAsSelected();
 
-      scope.selected = 'no match';
+      // This will select the empty option
+      scope.selected = null;
       scope.$digest();
 
+      expect(options[0]).toBeMarkedAsSelected();
+      expect(options[1]).not.toBeMarkedAsSelected();
+      expect(options[2]).not.toBeMarkedAsSelected();
+
+      // This will add and select the unknown option
+      scope.selected = 'unmatched value';
+      scope.$digest();
       options = element.find('option');
+
       expect(options[0]).toBeMarkedAsSelected();
       expect(options[1]).not.toBeMarkedAsSelected();
       expect(options[2]).not.toBeMarkedAsSelected();
+      expect(options[3]).not.toBeMarkedAsSelected();
+
+      // Back to matched value
+      scope.selected = 'b';
+      scope.$digest();
+      options = element.find('option');
+
+      expect(options[0]).not.toBeMarkedAsSelected();
+      expect(options[1]).not.toBeMarkedAsSelected();
+      expect(options[2]).toBeMarkedAsSelected();
     });
 
     describe('empty option', function() {
@@ -2358,6 +2414,35 @@ describe('select', function() {
           expect(previouslySelectedOptionElement).not.toBe(optionElements[0]);
       });
 
+
+      it('should validate when the options change', function() {
+          scope.values = ['A', 'B'];
+          scope.selection = 'A';
+
+          compile(
+            '<select ng-model="selection" required>' +
+              '<option value="">--select--</option>' +
+              '<option ng-repeat="option in values" value="{{option}}">{{option}}</option>' +
+            '</select>'
+          );
+
+          expect(element).toEqualSelect('', ['A'], 'B');
+          expect(element).toBeValid();
+          expect(ngModelCtrl.$error.required).toBeFalsy();
+
+          scope.$apply(function() {
+            // Only when new objects are used, ngRepeat re-creates the element from scratch
+            scope.values = ['B', 'C'];
+          });
+
+          expect(element).toEqualSelect([''], 'B', 'C');
+          expect(element).toBeInvalid();
+          expect(ngModelCtrl.$error.required).toBeTruthy();
+          // ngModel sets undefined for invalid values
+          expect(scope.selection).toBeUndefined();
+      });
+
+
     });