diff --git a/src/Umbraco.Core/DatabaseContext.cs b/src/Umbraco.Core/DatabaseContext.cs
index 1311593e90..ed9b7c5a9d 100644
--- a/src/Umbraco.Core/DatabaseContext.cs
+++ b/src/Umbraco.Core/DatabaseContext.cs
@@ -303,6 +303,8 @@ namespace Umbraco.Core
                     connString = ConfigurationManager.ConnectionStrings[GlobalSettings.UmbracoConnectionName].ConnectionString;
                 }
                 Initialize(providerName, connString);
+
+                DetermineSqlServerVersion();
             }
             else if (ConfigurationManager.AppSettings.ContainsKey(GlobalSettings.UmbracoConnectionName) && string.IsNullOrEmpty(ConfigurationManager.AppSettings[GlobalSettings.UmbracoConnectionName]) == false)
             {
@@ -339,6 +341,8 @@ namespace Umbraco.Core
 
                 //Remove the legacy connection string, so we don't end up in a loop if something goes wrong.
                 GlobalSettings.RemoveSetting(GlobalSettings.UmbracoConnectionName);
+
+                DetermineSqlServerVersion();
             }
             else
             {
@@ -372,6 +376,49 @@ namespace Umbraco.Core
             Initialize(providerName);
         }
 
+        /// <summary>
+        /// Set the lazy resolution of determining the SQL server version if that is the db type we're using
+        /// </summary>
+        private void DetermineSqlServerVersion()
+        {
+            
+            var sqlServerSyntax = SqlSyntaxContext.SqlSyntaxProvider as SqlServerSyntaxProvider;
+            if (sqlServerSyntax != null)
+            {
+                //this will not execute now, it is lazy so will only execute when we need to actually know
+                // the sql server version.
+                sqlServerSyntax.VersionName = new Lazy<SqlServerVersionName>(() =>
+                {
+                    try
+                    {
+                        var database = this._factory.CreateDatabase();
+
+                        var version = database.ExecuteScalar<string>("SELECT SERVERPROPERTY('productversion')");
+                        var firstPart = version.Split('.')[0];
+                        switch (firstPart)
+                        {
+                            case "11":
+                                return SqlServerVersionName.V2012;
+                            case "10":
+                                return SqlServerVersionName.V2008;
+                            case "9":
+                                return SqlServerVersionName.V2005;
+                            case "8":
+                                return SqlServerVersionName.V2000;
+                            case "7":
+                                return SqlServerVersionName.V7;
+                            default:
+                                return SqlServerVersionName.Other;
+                        }
+                    }
+                    catch (Exception)
+                    {
+                        return SqlServerVersionName.Invalid;
+                    }
+                });
+            }
+        }
+
         internal DatabaseSchemaResult ValidateDatabaseSchema()
         {
             if (_configured == false || (string.IsNullOrEmpty(_connectionString) || string.IsNullOrEmpty(ProviderName)))
@@ -463,6 +510,8 @@ namespace Umbraco.Core
                     message = message + "<p>Upgrade completed!</p>";
                 }
 
+                //now that everything is done, we need to determine the version of SQL server that is executing
+
                 LogHelper.Info<DatabaseContext>("Database configuration status: " + message);
 
                 return new Result { Message = message, Success = true, Percentage = "100" };
diff --git a/src/Umbraco.Core/Persistence/PetaPocoExtensions.cs b/src/Umbraco.Core/Persistence/PetaPocoExtensions.cs
index c962224689..eb10bf7f87 100644
--- a/src/Umbraco.Core/Persistence/PetaPocoExtensions.cs
+++ b/src/Umbraco.Core/Persistence/PetaPocoExtensions.cs
@@ -51,7 +51,10 @@ namespace Umbraco.Core.Persistence
 
             try
             {
-                if (SqlSyntaxContext.SqlSyntaxProvider is SqlCeSyntaxProvider)
+                //if it is sql ce or it is a sql server version less than 2008, we need to do individual inserts.
+                var sqlServerSyntax = SqlSyntaxContext.SqlSyntaxProvider as SqlServerSyntaxProvider;
+                if ((sqlServerSyntax != null && (int)sqlServerSyntax.VersionName.Value < (int)SqlServerVersionName.V2008) 
+                    || SqlSyntaxContext.SqlSyntaxProvider is SqlCeSyntaxProvider)
                 {
                     //SqlCe doesn't support bulk insert statements!
 
diff --git a/src/Umbraco.Core/Persistence/SqlSyntax/SqlServerSyntaxProvider.cs b/src/Umbraco.Core/Persistence/SqlSyntax/SqlServerSyntaxProvider.cs
index 2de2209ab4..3e37674ddf 100644
--- a/src/Umbraco.Core/Persistence/SqlSyntax/SqlServerSyntaxProvider.cs
+++ b/src/Umbraco.Core/Persistence/SqlSyntax/SqlServerSyntaxProvider.cs
@@ -13,6 +13,20 @@ namespace Umbraco.Core.Persistence.SqlSyntax
         public static ISqlSyntaxProvider Provider { get { return new SqlServerSyntaxProvider(); } }
     }
 
+    /// <summary>
+    /// Represents the version name of SQL server (i.e. the year 2008, 2005, etc...)
+    /// </summary>
+    internal enum SqlServerVersionName
+    {
+        Invalid = -1,
+        V7 = 0,
+        V2000 = 1,
+        V2005 = 2,
+        V2008 = 3,
+        V2012 = 4,
+        Other = 5
+    }
+
     /// <summary>
     /// Represents an SqlSyntaxProvider for Sql Server
     /// </summary>
@@ -36,6 +50,11 @@ namespace Umbraco.Core.Persistence.SqlSyntax
             InitColumnTypeMap();
         }
 
+        /// <summary>
+        /// Gets/sets the version of the current SQL server instance
+        /// </summary>
+        internal Lazy<SqlServerVersionName> VersionName { get; set; }
+
         public override string GetQuotedTableName(string tableName)
         {
             return string.Format("[{0}]", tableName);