bpy.ops.transform.rotate ignores pivot point
Use bmesh operators.

There are a number of bmesh operators that can be used for this transform. Here is an example using bmesh.ops.rotate(...)


The transform is performed in global space by using the matrix world of its object. S = ob.matrix_world.copy(). 
Using the global location of the scene cursor as pivot point pp = scene.cursor_location
The space is transposed such that the centre of the rotation is (0, 0, 0). S.transform -= pp


Example, run in edit mode, rotates selected vertices around the global Z axis, about the scene cursor location.

import bpy
import bmesh
from mathutils import Matrix
from math import radians

context = bpy.context
scene = context.scene
pp = scene.cursor_location
ob = context.edit_object
me = ob.data
bm = bmesh.from_edit_mesh(me)
S = ob.matrix_world.copy()
S.translation -= pp

R = Matrix.Rotation(radians(45), 3, (0, 0, 1))

bmesh.ops.rotate(bm, 
        matrix=R, 
        verts=[v for v in bm.verts if v.select],
        space=S)

bmesh.update_edit_mesh(me)


It's not a bug

The pivot point for transform operators is set in the UI.  Quite likely you have it set to object origin. 

To rotate, need an angle, an axis of revolution, and a point on that axis. The z axis has a direction of (0, 0, 1) and includes the origin point. 

Think of a wall full of clocks the axis of revolution for all is the same and is normal to the wall.  However each set of hands rotates around the local "center" of each clock.

The point on the axis is set via the pivot point.

The rotate operator has the center_override option.  Example with it set to rotate around the global point (0, 1, 0).

Note: center_override appears to be a new property, explains why I hadn't used it before lol.. Check the documentation of the blender version you are using. (Can confirm it's available in 2.80)

&gt;&gt;&gt; bpy.ops.transform.rotate(value=radians(45),
    axis=(0, 0, 1), 
    center_override=(0, 1, 0),
    constraint_orientation='GLOBAL')


For the most part wouldn't use the transform operators, rather apply matrices directly to the vertices.

Prior to the property, would need to override the area , space and possibly region context properties and pass as an override to the context.