
<p class="has-drop-cap">1Sju travlopp – på gräsbana. Det bjuds på Bro Park (första start 19.05)  när gräset får spela huvudrollen för en kväll i svensk travsport. Sundbyholmstravet satsar i samarbete med Bro Park på dubbla travdagar på gräset i sommar och nu är det dags för den första.</p>



<p>2023 var det travpremiär på Bro Park och förra året kördes och reds fem travlopp på gräset, där Magnus A Djuse och Oskar J Andersson tog varsin kuskdubbel och Sofia Adolfsson vann montéloppet. <br>Ikväll blir det fullt fokus på grästravet när det spetsas med V64-spel och sex sulkylopp i det gröna på kupongen. Totalt har det körts nio sulkylopp och av dessa har Magnus A Djuse vunnit fyra. Nu kör han i samtliga sex lopp.</p>



<p><a href="https://sulkysport.se/wp-content/uploads/2026/06/16v64.pdf" target="_blank" rel="noreferrer noopener">Här är startlistorna till Bro Parks travtävlingar.</a></p>



<p>Tisdag den 14 augusti kördes travlopp på Täby Galopp för första gången på 2000-talet när Torbjörn Jansson segrade med Anders Lindqvist-tränade <strong>Foreign Affair</strong> (e. Blue Eyes America). Två år senare lotsade Mikael Stärling <strong>Hugo Sting</strong> (e. Foreign Office), tränad av Jim Frick, till vinst.</p>



<p>Det året var det även travpremiär och sulkylopp på galoppgräset i Göteborg när Åbytravets nuvarande chef Jon Walter Pedersen vann med egentränade <strong>Outlook Express</strong> (e. Ata Star L.).<br>Där tävlades det både i trav och monté nästan årligen förutom några år i början av 2010-talet och sulkyvinnarna var: Bo Falsig (tre gånger), Lars Wester och Thomas Dalborg (två gånger), samt Mats C Nilsson, Jenny J Karlsson, Peter Norberg, Karl Stolt, Thomas Månsson, Iina Aho, Dwight Pieters och Henna Halme.</p>



<p>Sedan 2019 har det inte varit trav på Göteborg galopp, men i sommar är det dags igen den den 26 juli. </p>



<p class="has-text-align-center">***</p>



<figure class="wp-block-image size-sulky-mellan2"><img src="https://sulkysport.se/wp-content/uploads/2026/06/afairday1-617x333.jpg" alt="" class="wp-image-862496"/><figcaption class="wp-element-caption">A Fair Day och Oscar Ginman. Foto Mathias Hedlund/Sulkysport</figcaption></figure>



<p class="has-drop-cap">2För sex år sedan sprängdes 1.10-vallen för första gången på Kalmartravet när <strong>Tae Kwon Deo</strong> (e. Muscle Hill) och Adrian Kolgjini tog hem Kalmarsundspokalen över sprinterdistans med startbil på 1.09,6. Det blev starten för rena orgien tidsmässigt. Varje år under 2020-talet har det nämligen krävts en 1.09-tid för att vinna Kalmartravets gulddivisionslopp under midsommarhelgen!</p>



<p>Kanske är det dags att kliva in på 1.08-talet för första gången i Kalmars stora sprinterlopp? Banrekordet är vassa 1.09,1a/1.640 meter – och det är fyra hästar som delar på den noteringen.<br>En av dem är Elisabeth Almhedens hemmastjärna <strong>A Fair Day</strong> (e. Maharajah), som vann spårlottningen och drog perfekt utgångsläge med bricka ett bakom bilen tillsammans med Oscar Ginman. Precis det som var fallet vid fjolårets triumf i Kalmarsundspokalen, vilket förvaltades till ledning från start till mål.</p>



<p><a href="https://sulkysport.se/wp-content/uploads/2026/06/21v85.pdf" target="_blank" rel="noreferrer noopener">Här är startlistorna till söndagens V85-tävlingar i Kalmar.</a></p>



<p><strong>Här är alla vinnare under 1.11 i Kalmarsundspokalen</strong><br><em>År/häst (far) – Kusk – Segertid</em></p>



<ul class="wp-block-list">
<li>2021 <strong>Cokstile</strong> (e. Quite Easy) – Jorma Kontio – 1.09,1</li>



<li>2022 <strong>Click Bait</strong> (e. Cantab Hall) – Per Lennartsson – 1.09,1</li>



<li>2024 <strong>Don Fanucci Zet</strong> (e. Hard Livin) – Örjan Kihlström – 1.09,1</li>



<li>2026 <strong>A Fair Day</strong> (e. Maharajah) – Oscar Ginman – 1.09,1</li>



<li>2020 <strong>Tae Kwon Deo</strong> (e. Muscle Hill) – Adrian Kolgjini – 1.09,6</li>



<li>2023 <strong>Click Bait</strong> (e. Cantab Hall) – Per Lennartsson – 1.09,8</li>



<li>2017 <strong>B.B.S.Sugarlight</strong> (e. Super Light) – Kevin Oscarsson – 1.10,1</li>



<li>2015 <strong>Global Money</strong> (e. Love You) – Robert Bergh – 1.10,2</li>



<li>2016 <strong>B.B.S.Sugarlight</strong> (e. Super Light) – Peter Untersteiner – 1.10,2</li>



<li>2019 <strong>Slide So Easy</strong> (e. Quite Easy) – Flemming Jensen – 1.10,3</li>



<li>2018 <strong>Day Or Night In</strong> (e. Muscle Hill) – Johan Untersteiner – 1.10,4</li>



<li>2013 <strong>Shaq Is Back</strong> (e. Credit Winner) – Daniel Redén – 1.10,5</li>



<li>2012 <strong>Oracle</strong> (e. Ganymede) – Stefan Melander – 1.10,6</li>
</ul>



<p class="has-text-align-center">***</p>



<p class="has-drop-cap">3Vissa hästar kliver ut på tävlingsbanan med extra stort tryck på sig när det handlar om att leva upp till sina äldre syskon. På treåriga stoet <strong>Instant Glory</strong> (e. Readly Express) är trycket massivt och enormt. Hon är nämligen lillasyster till två Derbyvinnare!</p>



<p>Mamma <strong>Olympia Tilly </strong>(e. Lindy Lane-Pearl Tilly), 1.11,8ak/1.827.100 kr, är utsedd till Elitsto, det är också hennes mor <strong>Pearl Tilly</strong>, mormor <strong>Cikora Tilly</strong>, mormors mor <strong>Glenna H.</strong> och mormors mormor <strong>Scotch Dot</strong>!<br>Att Olympia Tilly nådde det epitetet tidigt i sin avelskarriär är inte konstigt. Två av hennes fyra första avkommor är <strong>Calgary Games</strong> (e. Readly Express) och <strong>Fame And Glory</strong> (e. Tactical Landing)!</p>



<p>Calgary Games tävlingskarriär tog slut efter tio segrar på elva starter, världsrekordet 1.11,7al* – sattes i Svenskt Travderby – och 6.685.000 kronor. Han vann även Europaderbyt och är sedan flera år flitigt anlitad avelshingst där hans äldsta avkommor är tre år.</p>



<p>Fame and Glory har gjort 14 starter (10-3-1) och sprungit in 10.603.521 kronor. På meritlistan finns segrar i både Svenskt Travkriterium och Svenskt Travderby. I slutet av november ifjol gjorde han första starten som femåring – efter 427 dagars (!) uppehåll – och tog hem semi-classique-löpningen Prix Doynel de Saint-Quentin (€120.000) på Vincennes.</p>



<p>Treåriga lillasystern Instant Glory är den sjunde i syskonskaran. Hon ägs av Stall Segerhuva och tränas av Conrad Lugauer, för vilken hon travade 1.19,2/2.140 i kvallopp i mitten av maj.</p>



<p>Idag på lunchbanan Gävle (första start 12.20) är det dags för tävlingsdebut i ett treåringslopp för ston i Svensk Travsports Unghästserie med 50.000 kronor till vinnaren.</p>



<p class="has-text-align-center">***</p>



<p class="has-drop-cap">4Det tävlas också traditionellt på grus i Sverige ikväll, där det blir dubbla kvällsbanor vid sidan om Bro Park.</p>



<p>På Jägersro (första start 17.45) gör Johan Untersteiners segermaskin <strong>Steady Express</strong> (e. Readly Express) andra starten efter långt uppehåll. Hästen hade nio raka (!) segrar förra sommaren och hösten innan han galopperade i bronsdivisionsfinalen på Solvalla annandag jul.<br>Steady Express var tillbaka på tävlingsbanan i slutet av maj, där det blev dubbla galopper på vägen till femteplatsen efter fin avslutning. Nu väntar spår åtta i ett åttahästarsfält och tränare Johan ska försöka påbörja en ny segerrad.</p>



<p>På Axevalla (första start 17.40) gör också en av profilerna förra året andra starten efter nästan elva månaders tävlingsuppehåll. Christoffer Erikssons <strong>Kyrie Eleison</strong> (e. Readly Express) vann tre raka V75-lopp i mars förra året, men är segerlös efter finaltriumfen på Solvalla.<br>Hästen försvann från tävlingsbanorna efter tredjeplatsen i silverförsöket under Halmstads Sprintermästarhelg och ställs nu mot sex motståndare i snabbloppet.</p>



<p><a href="https://sulkysport.se/wp-content/uploads/2026/06/260616.pdf" target="_blank" rel="noreferrer noopener">Här är startlistorna till tisdagens tävlingar.</a></p>



<p class="has-text-align-center">***</p>



<figure class="wp-block-image size-sulky-mellan2"><img src="https://sulkysport.se/wp-content/uploads/2026/05/5pro1-617x333.jpg" alt="" class="wp-image-856504"/><figcaption class="wp-element-caption">Pro vinner Elitkampen för Björn Goop. Foto Mathias Hedlund/Sulkysport</figcaption></figure>



<p class="has-drop-cap">5Midsommar i Finland innebär storlopp för kallblod på sommarbanan i Härmä, där 50.000 euro väntar vinnaren i Nordic King. För svensk del blir det bara en häst bakom startbilen i sprinterloppet på midsommardagen. Robert Skoglund låter tioårige dubbelmiljonären <strong>Sundbo Komet</strong> (e. Sundbo Kravall) ta båten till Finland.</p>



<p>Annars talar det mesta för hemmaseger med starka finska kort som Elitkampsvinnarna <strong>Pro</strong> (2026) och <strong>Evartti</strong> (2023), samt de senaste två årens Kungstravsvinnare V.G.Voitto.</p>



<p>Snabbloppet för varmblod med 20.000 euro till vinnaren ser fem hästar tränade i Sverige i startlistan. Daniel Wäjersten har duon <strong>Zaxton</strong> (e. Trixton) och <strong>Mellby Joker</strong> (e. Muscle Hill), Sandra Eriksson kör egentränade <strong>Devils Tongue</strong> (e. Zola Boko) och Alessandro Gocciadoro lotsar sin <strong>Executive Ek</strong> (e. Face Time Bourbon). Det femte bidraget är Petri Salmela-tränade <strong>Henry Flyer Sisu</strong> (e. Bold Eagle).</p>



<p><strong>Startlista Nordic King (€90.000)</strong><br>1.609 meter autostart, Härmä lördag<br><em>Häst (far) – Kusk</em></p>



<ol class="wp-block-list">
<li><strong>Lumettaja</strong> (e. Camri) – Terho Rautiainen</li>



<li><strong>Grislefaksen G.L.</strong> (e. Järvsöfaks) – Olli Koivunen</li>



<li><strong>Evartti</strong> (e. K.M.Nopsa) – Santtu Raitala</li>



<li><strong>Sundbo Komet</strong> (e. Sundbo Kravall) – Robert Skoglund</li>



<li><strong>Paavolan Hurmos</strong> (e. Villipappa) – Tommi Kylliäinen</li>



<li><strong>Enon Vilppi</strong> (e. Linkori) – Jari Autio</li>



<li><strong>Pro</strong> (e. Provinssi) – Hannu Torvinen</li>



<li><strong>V.G.Voitto</strong> (e. Viesker) – Ari Moilanen</li>



<li><strong>Stallone</strong> (e. Frans) – Jukka Torvinen</li>



<li><strong>Wertti</strong> (e. Costello) – Jani Routsalainen</li>
</ol>



<p class="has-text-align-center">***</p>



<p class="has-drop-cap">6Ickefranska travare gör sig inte besvär på Vincennes ikväll (första start 15.48), där samtliga åtta lopp är förbehållna franskfödda hästar.</p>



<p>Det blir ändå lite blågult på kolstybben. Jörgen Westholm äger franske miljonären <strong>Gitan de Touchyvon</strong> (e. Tiego d’Etangs), som hunnit bli tio år och numera återfinns i Ron Kuipers träning. Hästen har vunnit lopp fyra säsonger i rad i Frankrike (totalt åtta segrar).<br>I årsdebuten häromveckan blev det hejdlös startgalopp i ett montélopp. Samma disciplin gäller nu i lärlingsloppet Prix Henri Durand (€47.000) med hela 21.150 euro till vinnaren och Tom Cook sitter i sadeln.</p>



<p>Kuiper startar även stoet <strong>Julie du Nord </strong>(e. Un Mec d’Heripre) i amatörloppet Prix Felicia (€12.000). Barbara Guenet sitter i vagnen bakom Alf Nordemos travare.</p>



<p><a href="https://www.letrot.com/courses/programme/2026-06-16/7500" target="_blank" rel="noreferrer noopener">Här är startlistorna till Vincennes tävlingar.</a></p>



<p>Erik Lindegrens <strong>Ruger</strong> (e. Readly Express) har tävlat i Frankrike det senaste året och vunnit två lopp på 15 försök. Idag går turen till medelhavsstaden Hyeres, där Ruger startar i Prix Michel Viard (€26.000) över 2.650 meter med David Bekaert i vagnen. Bland motståndarna finns Geir Vegard Gundersens <strong>Orlando Young</strong> (e. Orlando Vici), som debuterar på fransk mark med Pierre Vercruysse i vagnen.</p>



<p class="has-text-align-center">***</p>



<p class="has-drop-cap">7I slutet av maj meddelade Svensk Travsport och ATG att starttiden för lördagarna tidigareläggs till V85-start klockan 15.00 från och med Derbyhelgen på Jägersro i september. Sista avdelningen på streckspelet beräknas starta 17.35.</p>



<p>För norsk del består många lördagar av konceptet ”Super Saturday”, där norrmännen först spelar till svenska V85 innan en egen V75-omgång tar vid på kvällen. Dessa har varit under attack från aktiva med tanke på sena lördagskvällar, men nu blir starttiderna tidigarelagda även i Norge, berättar norska travförbundet på sin hemsida.</p>



<p>En timme tidigare är det som gäller från september, vilket innebär att sista V75-loppet startar runt klockan 21, istället för för nu klockan 22.05.<br><em>”Sportens aktiva får från och med den dagen avsluta sin arbetsdag en timme och tio minuter tidigare jämfört med dagens tidsschema,” </em>skriver DNT.</p>

Fokustema
Sju nyheter vid sju
Läs senare
Den svenske gräskungen
Han har vunnit mest på svenska grästrav. Drömläge för repris för A Fair Day. Debut för Calgary Games och Fame And Glorys lillasyster. Svenska hoppet i finskt miljonlopp. Norge tar rygg på Sverige på lördagar.
Detta och mer bland tisdagens ”Sju nyheter vid sju”.
Detta och mer bland tisdagens ”Sju nyheter vid sju”.
