A few things:

• 1595357722990 is a Unix timestamp with millisecond precision, equal to 2020-07-21 18:55:22.990 UTC. The web site you were checking it against is converting it to your local time. Here's a fiddle showing the conversion with .NET code., and here's it in JavaScript:

const dt = new Date(1595357722990);
console.log(dt.toISOString());

• You really should avoid JavaScriptSerializer. The docs say:

  ⓘ Important

  For .NET Framework 4.7.2 and later versions, the APIs in the System.Text.Json namespace should be used for serialization and deserialization. For earlier versions of .NET Framework, use Newtonsoft.Json.

• The format "\\/Date(1595357722990)\\/" is often refered to as an "ASP.NET JSON Date", because it was first released onto the world with early versions of ASP.Net, around the time that JSON starting becoming more prevalent than XML. It was a bad format then, and it is bad now. See On the nightmare that is JSON Dates... from Scott Hanselman back in 2012.

• You should instead use the ISO 8601 extended date+time format (see also RFC 3339), which is the default for most modern JSON implementations, including Newtosoft JSON.Net and System.Text.Json.

• You said:

  Timestamp would be set to 7/21, 6:55:22 and the Kind property would be set to Utc. This is incorrect.

  No, it is actually correct - assuming you meant PM. That's the value 1595357722990 represents. Probably you are creating that value incorrectly (see further below).

• In most cases, including yours, you shouldn't need to change the default DateTimeZoneHandling option of JSON.Net.

• You said your desired output is to have DateTimeKind.Utc - but it seems you meant after your conversion to local time? That doesn't make sense. If you are converting to local time, then the resulting kind would be DateTimeKind.Local.

• You would be fine just using TimeZoneInfo.ConvertTime in this case. Since the input kind is already set to DateTimeKind.Utc, the ...FromUtc part isn't necessary. (That only really matters when the input kind is DateTimeKind.Unspecified.)

• Looking at your edit, it seems you are actually storing 2020-07-21T13:55:22.99 in your database. If that field is intended to be interpreted as UTC, then indeed you should see hour 13 in the resulting JSON. However, it should also include a trailing Z to indicate that the data is UTC.

  Your JSON should actually look like this:

  [
      {
          "Timestamp":"2020-07-21T13:55:22.990Z"
      }
  ]
  

  It might have a few extra decimals places by default, which is fine.

• The reason you aren't getting that result, and why the original value created by JavaScriptSerializer is wrong, is because you're not setting DateTimeKind.Utc on the values read from the database. You need to change your code to do that explicitly, using DateTime.SpecifyKind. For example, you could modify your inner loop to:

  foreach (DataColumn column in dataTable.Columns)
  {
      object o = row[column];
      if (o is DateTime)
      {
          o = DateTime.SpecifyKind((DateTime)o, DateTimeKind.Utc);
      }
  
      rowAsDictionary.Add(column.ColumnName, o);
  }
  

• In general, you've got a lot going on in your code that is sub-optimal. Really you should be using an enumerable or list of a structured class instead of a dictionary of objects, and you should be using a DataReader rather than DataTable. Also, in most frameworks, such as in ASP.net, you should return that list directly and let the framework do the JSON conversion. In other words, you probably should not convert to JSON in this method at all.

It's been a while. Nobody else has given an answer and I've been using the solution I posted in the Edit for quite some time. So, I'm going to mark it as the answer.

Ultimately, the serializer I was using was old and not good. I thought I was using Newtonsoft, but I was wrong.

The method needs to be changed to this:

private static string GetJSONFromSQLQuery(string query, string connectionString)
{
    var dataTable = new DataTable();

    using (var sqlConnection = new SqlConnection(connectionString))
    using (var sqlCommand = new SqlCommand(query, sqlConnection))
    using (var sqlDataAdapter = new SqlDataAdapter(sqlCommand))
    {
        sqlConnection.Open();
        sqlDataAdapter.Fill(dataTable);
    }

    var rowsAsDictionaries = new List<Dictionary<string, object>>();
    foreach (DataRow row in dataTable.Rows)
    {
        var rowAsDictionary = new Dictionary<string, object>();

        // ReSharper disable once LoopCanBeConvertedToQuery
        foreach (DataColumn column in dataTable.Columns)
            rowAsDictionary.Add(column.ColumnName, row[column]);

        rowsAsDictionaries.Add(rowAsDictionary);
    }

    // The original return statement:
    //return new JavaScriptSerializer().Serialize(rowsAsDictionaries);

    // The correct return statement:
    return JsonConvert.SerializeObject(rowsAsDictionaries);
}

As PanagiotisKanavos said:

new JavaScriptSerializer() is not JSON.NET. It's an obsolete .NET serialised used as a stop-gap. It had a lot of quirks so people avoided it when possible. ASP.NET WebAPI and .NET Core up to 2.2 uses JSON.NET. .NET Core 3.1 uses a new JSON serialised that's even stricter

Also, a little out of scope, but if anyone wants an async method, this works:

private static async Task<string> GetJSONFromSQLQueryAsync(string query, string connectionString)
{
    var dataTable = new DataTable();

    using (var sqlConnection = new SqlConnection(connectionString))
    {
        await sqlConnection.OpenAsync();
        using var sqlCommand = new SqlCommand(query, sqlConnection);
        using var reader = await sqlCommand.ExecuteReaderAsync();

        dataTable.Load(reader);
    }

    var rowsAsDictionaries = new List<Dictionary<string, object>>();
    foreach (DataRow row in dataTable.Rows)
    {
        var rowAsDictionary = new Dictionary<string, object>();

        // ReSharper disable once LoopCanBeConvertedToQuery
        foreach (DataColumn column in dataTable.Columns)
            rowAsDictionary.Add(column.ColumnName, row[column]);

        rowsAsDictionaries.Add(rowAsDictionary);
    }

    return JsonConvert.SerializeObject(rowsAsDictionaries);
}