
<p class="has-drop-cap wp-block-paragraph">1 Åby Stora Pris, med 1,5 miljon kronor till vinnaren har formats och stöpts i olika former genom historien. Idag är det tre varv som gäller för de tolv deltagarna, men det har funnits varianter som varit riktiga publikdragare på annat sätt tidigare år. Som till exempel när det kördes två heatlopp över kort distans, där ekipagen vände på startordningen till det andra heatet.</p>



<p class="wp-block-paragraph">Minnesvärda vinnare från just de upplagorna är många och redan första året med två lopp över 1.640 meter fick publiken njuta av ett skiljeheat mellan <strong>Steinlager</strong> och <strong>Gidde Palema</strong>, där den sistnämnde var starkast och vann på 1.13,3a/1.640 meter till oddset 1.40.</p>



<p class="wp-block-paragraph">Åtta gånger mellan åren 2005 och 2017 tvingades Åby Stora Pris avgöras genom skiljeheat och den stora svenska underdogen som besegrade tungviktaren från Frankrike 2008 var Lutfi Kolgjinis <strong>Garland Kronos</strong>, som i en ren speeduppgörelse höll Elitloppsvinnaren L&#8217;Amiral Mauzun bakom sig över Åbys upplopp.</p>



<h2 class="wp-block-heading">Skiljeheatsvinnare i Åby Stora Pris 2005-2017</h2>



<p class="wp-block-paragraph">År – Häst – Tränare</p>



<ul class="wp-block-list">
<li>2005 – Gidde Palema – Åke Svanstedt</li>



<li>2007 – Giant Superman – Fredrik B Larsson</li>



<li>2008 – Garland Kronos – Lutfi Kolgjini</li>



<li>2013 – Sebastian K. – Åke Svanstedt</li>



<li>2014 – Commander Crowe – Fabrice Souloy</li>



<li>2015 – Support Justice – Geir Vegard Gundersen</li>



<li>2016 – Un Mec d’Heripre – Fabrice Souloy</li>



<li>2017 – Midnight Hour – Ossi Numonen</li>
</ul>



<p class="wp-block-paragraph">Sedan 2018 har Åby Stora Pris körts över 3.140 meter och för två år sedan ingick loppet i penningstinna Åby World Grand Prix med 6.000.000 kronor till vinnande <strong>Horsy Dream</strong>.</p>



<p class="wp-block-paragraph">1983, <strong>Legolas</strong>, eller 1988 <strong>Ourasi</strong>? Självklart var Legolas seger i Åby Stora Pris en höjdare för den svenska travpubliken, men att Ourasi satte sina hovar på svensk mark och vann är så här idag, 38 år senare, ett fantastiskt minne för alla som var på plats.</p>



<figure class="wp-block-image size-sulky-mellan2 is-resized"><img src="https://sulkysport.se/wp-content/uploads/2025/05/ducs1-617x330.jpg" alt="" class="wp-image-717709" style="width:677px;height:auto"/><figcaption class="wp-element-caption">Ibiki de Houelle missade Harper Hanovers lopp, men får en ny chans på svensk mark i Åby Stora Pris idag. Foto: Gerard Forni</figcaption></figure>



<p class="wp-block-paragraph">Idag är det nya stjärnor som gör upp om trofén och från Frankrike kommer hästen som ser ut att bli favorit på spelet, <strong>Ibiki de Houelle</strong> (e. Love You) och han kommer att få känna på hur det är att möta två av årets Prix d&#8217;Amérique-deltagare i form av <strong>Epic Kronos</strong> (e. Muscle Hill) och <strong>Francesco Zet</strong> (e. Father Patrick).</p>



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



<p class="has-drop-cap wp-block-paragraph">2 Åby travbana fyller 90 år i år och dagens tävlingsdag (start 14.35) med STL-klasslopp innehåller även Ragnar Thorngrens Minne för fyraåriga hästar, dit endast sex ekipage kommer till start. Men det kan likväl bli en spännande strid mellan formtoppade <strong>Jonte Godiva</strong> (e. Who&#8217;s Who) och snabbe <strong>Chat Room</strong> (e. Chapter Seven).</p>



<p class="wp-block-paragraph">Den förstnämnde övertygade stort vid segern i ett Breeders Crown-försök för två veckor sedan och kanadaimporten Chat Room svarade för en vass upphämtning efter galopp i Prix Cagnes-sur-Mer på Jägersro under Hugo Åbergs-kvällen.</p>



<p class="wp-block-paragraph"><a href="https://sulkysport.se/spelstugan/v85-tips-aby-15-aug/" target="_blank" rel="noreferrer noopener">––––>>> Läs vad experterna tror om Åbys V85-omgång här.</a></p>



<p class="wp-block-paragraph"><a href="https://www.atg.se/butik/69ansspel/V85_2026-08-15_6_5" target="_blank" rel="noreferrer noopener">Här hittar du andelar till 69:ans Tobaks V85-rader.<br></a><a href="https://www.atg.se/butik/spelpoolen/V85_2026-08-15_6_5" target="_blank" rel="noreferrer noopener">Här hittar du andelar till Spelpoolens V85-rader.</a></p>



<p class="wp-block-paragraph"><a href="https://sulkysport.se/wp-content/uploads/2026/08/15v85.pdf" target="_blank" rel="noreferrer noopener">Startlistor till Åbys tävlingar hittar du här.</a></p>



<p class="wp-block-paragraph">Det körs även breddtrav på Romme denna lördag med elva lopp på menyn. <strong>Mio Arneng</strong> är ännu för ung för att få köra totolopp, men i Rommes inledande lopp, som ingår i Juniorchansen, har han chansen att ta årets 17:e seger i 46:e starten.</p>



<p class="wp-block-paragraph"><a href="https://sulkysport.se/wp-content/uploads/2026/08/260815.pdf" target="_blank" rel="noreferrer noopener">Startlistor till dagens tävlingar hittar du här.</a></p>



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



<p class="has-drop-cap wp-block-paragraph">3 Finskt Derby (€200.000) står på agendan på Vermo denna lördag. Det är dåligt med svenskt deltagande i loppet i år, men hoppet står till Jorma Kontio, som sitter upp bakom Matti Nisonen-tränade  <strong>Callela Classico</strong> (e. Classic Photo) och man börjar från bakspår över 2.640 meter.</p>



<p class="wp-block-paragraph">Det körs också Finskt Mästerskap, där välkända namn som <strong>Massimo Hoist</strong> (e. Muscle Hill) och <strong>Run For Royalty </strong>(e. R C Royalty) är de mest meriterade i gänget.</p>



<h2 class="wp-block-heading">Startlista Finskt Travderby (€215.000)</h2>



<p class="wp-block-paragraph">2.640 meter autostart, Vermo 15 augusti<br>Häst (far) – Tränare – Körsven</p>



<ol class="wp-block-list">
<li>Magnitude (e. Maharajah) – Hannu-Pekka Korpi – Ari Moilanen</li>



<li>Callela Capiano (e. Maharajah) – Timo Korvenheimo – Iikka Nurmonen</li>



<li>Like My Dream (e. Maharajah) – Tapio Perttunen </li>



<li>Stonecapes Yoda (e. Southwind Frank) – Harry Koivunen</li>



<li>Ancio (e. Nuncio) – Markku Nieminen – Santtu Raitala</li>



<li>Uranus Orden (e. Brad de Veluwe) – Anna Torvinen – Hannu Torvinen</li>



<li>Ashley Spy (e. Orlando Vici) – Sanna Kiiski – Tommi Kylliäinen</li>



<li>Prasutagus Secret (e. Tobin Kronos) – Harry Koivunen – Olli Koivunen</li>



<li>EL Narnia (e. EL Titan) – Hannu-Pekka Korpi – Janne Korpi</li>



<li>Green’s Third Try (e. Friendly Bourbon) – Tuomas Korvenoja</li>



<li>Callela Classico (e. Classic Photo) – Matti Nisonen – Jorma Kontio</li>



<li>Make Cash (e. Maharajah) – Markku Nieminen – Jukka Torvinen</li>
</ol>



<h2 class="wp-block-heading">Startlista Finskt Mästerskap (€25.000)</h2>



<p class="wp-block-paragraph">Häst (far) – Tränare – Körsven</p>



<ol class="wp-block-list">
<li>Knight Rider Hoss (e. Scarlet Knight) – Harri Koivunen – Olli Koivunen</li>



<li>EL Jetpack (e. EL Titan) – Pekka Korpi – Ari Moilanen</li>



<li>Corazon Combo (e. Express Duo) – Pekka Korpi – Tommi Kylliäinen</li>



<li>Run For Royalty (e. RC Royalty) – Pekka Korpi – Janne Korpi</li>



<li>Amazing Player (e. Quite Easy) – Irina Sarin – Jarmo Saarela</li>



<li>Main Stage (e. Prodigious) – Antti Ojanperä – Santtu Raitala</li>



<li>Kyle Web (e. Like A Prayer) – Timo Korvenheimo – Iikka Nurmonen</li>



<li>Amanda Evo (e. Brillantissime) – Dimitri Hedman – Ville Koivisto</li>



<li>Massimo Hoist (e. Muscle Hill) – Riina Korhonen – Hannu Torvinen</li>



<li>The Lost Battalion (e. Flocki d’Aurcy) – Heli Taipale – Esa Holopainen</li>



<li>Stoneisle Vertigo (e. Creatine) – Tapio Perttunen</li>



<li>Fly By Me (e. Muscle Mass) – Harri Koivunen</li>
</ol>



<p class="wp-block-paragraph"><a href="https://sulkysport.se/wp-content/uploads/2026/08/15vermo.pdf" target="_blank" rel="noreferrer noopener">Startlistor till Vermos tävlingar hittar du här.</a></p>



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



<p class="has-drop-cap wp-block-paragraph">4 Jydsk Vaeddelöbsbana i Århus (första start kl. 13.00) bjuder på finaler i Jydsk 3-årings Grand Prix. Störst intresse drar obesegrade <strong>Menza</strong> (e. Readly Express) och han jagar 13:e raka segern och ett förstapris på 393.000 danska kronor i den öppna klassen.  </p>



<p class="wp-block-paragraph">Birger Jörgensen sitter som vanligt i sulkyn bakom Gordon Dahls treåring och normalt sett blir han svårslagen. Från Sverige deltar Ken Ecce med <strong>Morningstar Derm</strong> (e. Nuncio) och sedan sitter Jörgen Sjunnesson upp bakom Christian Lindharts <strong>Magic Speed</strong> (e. Maharajah) i samma lopp. </p>



<p class="wp-block-paragraph">Jörgen Sjunnesson får också chansen i stonas final och där lockas det med ett förstapris på 222.000 danska kronor för de ston som är premiechansade. Magda och My Dear Hyrdehöj får nöja sig med 148.000 danska kronor vid eventuell seger. <strong>Makemoni M.S.</strong> (e. International Moni) jagar sin fjärde raka seger och precis som Magic Speed tränas hon av Christian Lindhardt.</p>



<h2 class="wp-block-heading">Jydsk 3-årings Grand Prix</h2>



<p class="wp-block-paragraph">Treåringar.</p>



<p class="wp-block-paragraph">Priser: 393.000-196.500-94.500-47.250-31.500-23.250-12.000 dkk.<br>2.360 meter, autostart.<br>Namn (far) – Körsven</p>



<ol class="wp-block-list">
<li>Maddox (e. Father Patrick) – Kasper Foget</li>



<li>Magnus Tinghöj (e. Nuncio) – Jeppe Juel</li>



<li>Menza (e. Readly Express) – Birger Jörgensen</li>



<li>Magic Speed (e. Maharajah) – Jörgen Sjunnesson</li>



<li>Mester C.N. (e. Ens Snapshot) – Jan Dahlgaard</li>



<li>Malthe S.H. (e. Calgary Games) – Casper M Nielsen</li>



<li>Mafioso (e. Nuncio) – Rene Kjaer</li>



<li>Muscle Laser (e. Forever Peace) – Jeppe Rask</li>



<li>Mason (e. Mosaique Face) – Patrick Larsen</li>



<li>Morgan Cash (e. Italiano Vero) – Knud Mönster</li>



<li>Matias Bork (e. Great Challenger) – Morten Friis</li>



<li>Morningstar Derm (e. Nuncio) – Ken Ecce</li>
</ol>



<h2 class="wp-block-heading">Jydsk 3-årings Grand Prix</h2>



<p class="wp-block-paragraph">Treåriga ston.<br>Priser: 222.000-111.000-54.000-27.000-18.000-13.500-6.750-6.750 dkk.<br>1.800 meter, autostart.<br>Namn (far) – Körsven</p>



<ol class="wp-block-list">
<li>Monterey Market (e. Googoo Gaagaa) – Patrick Larsen</li>



<li>Maggi Wee (e. Calgary Games) – Casper M Nielsen</li>



<li>Makememoni M.S. (e. International Moni) – Jörgen Sjunnesson</li>



<li>Merle (e. Wishing Stone) – Kasper Foget</li>



<li>Mariel (e. Maharajah) – Birger Jörgensen</li>



<li>Magda* (e. Quick Wood) – Jim G Veldman</li>



<li>Mynte Mosebo (e. Dominion Beach) – Nicklas Korfitsen</li>



<li>Mountain Dust (e. Readly Express) – Jan Dahlgaard</li>



<li>Manhattan Cocktail (e. International Moni) – Jeppe Juel</li>



<li>Moon Dust (e. Raja Mirchi) – Henrik Lönborg</li>



<li>Ma Belle (e. S.J.’s Caviar) – Martin Hansen</li>



<li>My Dear Hyrdehöj* (e. From Above U.S.) – Magnus M Nielsen</li>
</ol>



<p class="wp-block-paragraph">Fonot: *hästarna är inte premiechansade utan tävlar om prisskalan: 148.000-74.000-36.000-18.000-12.000-9.000-4.500-4.500 dkk.</p>



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



<p class="has-drop-cap wp-block-paragraph">5 Mariendorf-banan bjuder på finalen i Tyskt Stoderby (€112.920) för fyraåriga ston ikväll och finalen körs klockan 21.50 utan några blågula inslag bland de tvåbenta. </p>



<p class="wp-block-paragraph"><strong>Myrena</strong> (e. Mister J.P.) var snabbast i kvalet med seger på 1.11,7a/1.900 meter och Michel Rothengatter får chansen i sulkyn. Bland motståndarna finns Wolfgang Nimczyks duon <strong>Brownie Diamant</strong> (e. Indigious) och <strong>Mille Fleurs</strong> (e. Fabulous Wood), som vann sina respektive försök på 1.13,8 respektive 1.13,1. Den sistnämnda är obesegrad i fyra starter i år.</p>



<h2 class="wp-block-heading">Tyskt Stoderby (€112.920)</h2>



<p class="wp-block-paragraph">Fyraåriga ston. <br>1.900 meter, autostart. <br>Namn (far) – Körsven</p>



<ol class="wp-block-list">
<li>Choupette (e. Maharajah) – Thorsten Tietz</li>



<li>Brownie Diamant (e. Indigious) – Michael Nimczyk</li>



<li>Myrena (e. Mister J.P.) – Michel Rothengatter</li>



<li>Mille Fleurs (e. Fabulous Wood) – Jaap van Rijn</li>



<li>Thanks (e. Cantab Hall) – Dennis Spangenberg</li>



<li>Valparaiso (e. Love You) – Marciano Hauber</li>



<li>Daireann (e. Broad Bahn) – Josef Franzl</li>



<li>Gold Girl HB (e. Googoo Gaagaa) – Robbin Bot</li>



<li>Xalina B (e. Booster Winner) – Marisa Bock</li>



<li>Stonehillpearl (e. Muscle Hill) – vakant</li>



<li>Käthe (e. Maharajah) – Micha Brouwer</li>



<li>Mon Jolie (e. Wishing Stone) – Thomas Panshow</li>
</ol>



<p class="wp-block-paragraph">Tidigare under kvällen avgörs också finalen i Super Trot Cup (€70.000) där det lockas med 35.000 euro i förstapris i ett lopp över 2.500 meter, autostart. </p>



<p class="wp-block-paragraph">Fem hästar deltar med svensk anknytning;<strong> Custom Chef/Tyler Mifsud</strong>, <strong>Brilliant Kid/Peter G Norman</strong>, <strong>De Chambeau/André Eklundh</strong>, <strong>Friendofthephantom/Conrad Lugauer</strong> och <strong>Landmark River/Noa Relden</strong>.</p>



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



<p class="has-drop-cap wp-block-paragraph">6 Dubbelt svenskt blev det när Prix de Villedieu-les-Poeles (€33.000) avgjordes i Cabourg igår kväll. Erik Lindegren-tränade <strong>Ruger</strong> (e. Readly Express) håller grym Frankrike-form för tillfället och tredje segern på kort tid – andra raka – togs efter att körande Florian Desmigneux hamnat sist i fältet efter start, för att sedan glida fram i tredjespår 1.550 meter från mål.</p>



<figure class="wp-block-image size-sulky-mellan2"><img src="https://sulkysport.se/wp-content/uploads/2026/08/skarmavbild20260814kl.22.52.57-617x358.jpg" alt="" class="wp-image-886305"/><figcaption class="wp-element-caption">Ruger vid segern i Cabourg igår.</figcaption></figure>



<p class="wp-block-paragraph">Greppet kopplades i mitten av slutsvängen på högervarvsbanan i Cabourg och Ruger försvann till lätt seger på 1.12,2a/2.725 meter. Jörgen Westholms Red Hot Roadster (e. Red Hot Dynamite) gjorde ett starkt dagsverke även han, när han tågade i tredjespår sista kilometern för att avsluta bra långt ut i banan som tvåa på 1.12,5a/2.725 meter.</p>



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



<p class="has-drop-cap wp-block-paragraph">7 <strong>William Ekberg</strong> får ta emot Joakim Sandkvists Stipendiat 2026 och priset delas ut i Halmstad den 24 augusti. Ekberg är proffstränare på Axevalla, än så länge, men kommer att flytta till Örebro och en egen gård under kommande höst. I år har han en segerprocent på 14 efter 111 starter och hans hästar har sprungit in närmare 1,5 miljon kronor.</p>



<figure class="wp-block-image size-sulky-mellan2"><img src="https://sulkysport.se/wp-content/uploads/2021/07/williamekberg1-617x333.jpg" alt="" class="wp-image-186292"/><figcaption class="wp-element-caption">William Ekberg. Foto Mathias Hedlund/Sulkysport</figcaption></figure>



<p class="wp-block-paragraph"><strong>Motiveringen till utnämningen av Joakim Sandkvists Stipendiat lyder:<br></strong><em>&#8221;Vinnaren har trots sin ringa ålder (född 1997) varit aktiv inom travet i många år. <br>Han har gjort sig känd som en skicklig lärling, vunnit EM-guld för lärlingar 2022 och numera etablerat sig som A-tränare med hemmabana Axevalla där han tog ut sin proffslicens 2025.</em></p>



<p class="wp-block-paragraph"><em>Han är ambitiös, ödmjuk och har ett stort driv. Med 17 hästar på träningslistan och en nyinköpt gård, nära sina hemtrakter Örebro, bygger han sin framtid med en modern träningsanläggning där fokus är att arbeta efter hästägaren i centrum.</em></p>



<p class="wp-block-paragraph"><em>Hans starka resultat och med en tydlig satsning framåt uppfyller han kriterierna för Joakim Sandkvist Stipendiat på ett synnerligen gott vis.&#8221;</em></p>
