
<p class="has-drop-cap">1Lindesberg är något av Timo Nurmos hemmaplan, i alla fall när man ser till segeraptiten. Sedan 2012 har han blivit segerrikaste tränare i Lindesberg 13 av 14 år. Den ende som kunnat bryta sviten var Mattias Djuse 2024.<br>Vid åtta av dessa tillfällen har segerprocenten varit 40 eller bättre för Nurmostränade hästar med toppnoteringarna 2013 (53,6 procent – 15 av 28 segrar), 2017 (53,1 procent – 17 av 32), 2019 (50 procent – 14 av 28) och 2022 (50 procent – 225 av 44).</p>



<p>I år har det hittills ”bara” blivit åtta Nurmos-starter i Lindesberg och fem har slutat med seger – 62,5 i segerprocent!</p>



<p>När Lindesberg (första start 13.45) tävlar i eftermiddag kan segerantalet fyllas på rejält när Nurmos sänder dit fem av stallets 73 hästar på segerjakt. För segrar brukar det som sagt bli. Ifjol inledde bland annat blivande världsrekordtravaren och Oaksvinnaren <strong>Moder Teresa Sisu</strong> (e. Walner) tävlingskarriären med vinst i Lindesberg.</p>



<p>Tre treåringar bjuder Nurmos på i form av debutanten <strong>Global Holdings</strong> (e. Southwind Frank) – lillebror till femfaldige miljonären <strong>Global Trustworthy</strong> – <strong>Pure Gold Zaz</strong> (e. Goimng For Gold Zaz), som vunnit två av tre starter, och <strong>Cameron Poe</strong> (e. Muscle Hill) med en seger på två försök. Dessutom kliver flitigt rikstotomatchade <strong>Keep Gamble</strong> (e. Cash Gamble) ned i klass i ett ”vanligt” lopp. Nurmoskvintetten kompletteras av fyraårige <strong>Play The Music</strong> (e. Nuncio) med två raka segrar i bagaget.</p>



<p>Vem kan stå upp mot Nurmos? Ja, Robert Bergh vill definitivt ha ett ord med i laget. Han är faktiskt vassare än Solvallatränaren i Lindesberg i år med fem segrar på sju starter som tränare – segerprocent 71,4! – och har hela åtta hästar till start. Bland dessa finns treåriga årsdebutanten <strong>Deer Hunter</strong> (e. Bird Parker). Stoet gjorde tre starter ifjol som tvååring och vann. samtliga. Som snabbast travade hon 1.15,0a/2.140 meter – nytt svenskt rekord!</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/07/readytrophyiaadamstalltz-617x333.jpg" alt="" class="wp-image-878271"/><figcaption class="wp-element-caption">Årets sista gräslopp i Sverige avgörs idag och då kan Mikko Aho-tränade Ready Trophy ta andra raka på gräset tillsammans med Iina Aho. Ekipaget vann på Bro Park i maj. Foto Adam Ström/stalltz.se</figcaption></figure>



<p class="has-drop-cap">2Aldrig har det körts och ridits så många travlopp på gräs i Sverige som i år. Tolv lopp har avgjorts på Bro Park och idag på galoppbanan i Göteborg är det dags för årets två sista lopp på underlaget. </p>



<p>2003 var det sulkylopp på galoppgräset i Göteborg för första gången 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>Efter 2018 har det dock varit stopp, ända till idag. Ett sulkylopp och en montélopp för travare står på programmet i samband dagens galopptävlingar. 13 hästar på fyra volter över medeldistans tävlar i sulkyloppet, medan elva finns med i monté.</p>



<p>Två miljonärer jagar längst bak för sulky och Mikko Aho-tränade tioåringen <strong>Ready Trophy</strong> (e. Ready Cash) har färsk gräsform. Han vann nämligen tillsammans med Iina Aho på Bro Park för en dryg månad sedan och Iina sitter i vagnen även idag. Den andre miljonären är Markus Waldmüller-tränade segermaskinen <strong>Frankie Godiva</strong> (e. Readly Express), som vunnit 17 av 48 starter hittills i karriären.</p>



<p>40.000 kronor väntar vinnarna i båda loppen.</p>



<p><a href="https://sulkysport.se/wp-content/uploads/2026/07/260726.pdf" target="_blank" rel="noreferrer noopener">Här är startlistorna till dagens 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/2022/08/jillivarsson-617x333.jpg" alt="" class="wp-image-336736"/><figcaption class="wp-element-caption">Jill Ivarsson. Foto Mathias Hedlund/Sulkysport</figcaption></figure>



<p class="has-drop-cap">326-åriga Danneroamatören Jill Ivarsson närmar sig en fortsatt karriär som proffstränare. Hon har gått proffstränarkursen och i stallet finns för dagen 13 hästar.</p>



<p>Igår gjorde hon reklam för sig själv som kusk när hon tog hem ungdomsfinalen Järvsöfaks Cup i Bollnäs tillsammans med Tage Bergman-tränade <strong>Trönö Borken</strong> (e. Ängsborken). Femåringen räknade in tredje raka segern och har vunnit hälften av livets 16 starter.<br>Det var inte första gången Jill stiftade bekantskap med hästen. I början av vann nämligen duon första försöket i Järvsöfaks Cup, även det i Bollnäs.</p>



<p>Jill Ivarsson är också en av sex uttagna i ATG Talang, där unga får chansen till fortbildning vid fyra tillfällen under året.</p>



<p><strong>Här är årets utvalda talanger:</strong></p>



<ul class="wp-block-list">
<li>Jill Ivarsson, Dannero</li>



<li>Niclas Hammarström, Solvalla</li>



<li>Viktoria Berntsson, Axevalla</li>



<li>Simon Mitman, Jägersro</li>



<li>Jakob Smith, Mantorp</li>



<li>Alina Öhgren, galoppjockey (bas på Bro Park)</li>
</ul>



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



<p class="has-drop-cap">4Förra året slutade <strong>Javier Zet</strong> (e. Don Fanucci Zet), 1.12,8am/607.750 kr, femma i Svenskt Travkriterium med tränaren Daniel Redén i vagnen. Igår kväll sålde Stall Zet hästen på Traveras auktion, där Linnea Johansson hade högsta budet på 190.000 kronor. Efter två segrar och andraplatsen i Kriteriekvalet har Javier Zet en sjundeplats som bäst på tre försök i år.<br>Även en annan fyraårig Don Fanucci Zet-son från Stall Zet var uppe i den digitala auktionsringen och <strong>Jeremy Zet </strong>klickades hem för 210.000 kronor av Attractive Lines AB.</p>



<p>Dyrast på Traveraauktionen var treårige <strong>Västerbo Bugger</strong> (e. Inernational Moni), som tränas av André Eklundh, där högsta budet blev 420.000 kronor. Sex starter i år har slutat med två segrar och ytterligare två pallplatser för valacken, som sprungit in 152.000 kronor. <br>Köpare var Agne Svenberg från Färjestaden – Rustik Power AB – som i slutade av maj även köpte <strong>Howtoreach W.F.</strong> (e. Readly Express), 1.12,4am/332.400 kr, på Travera för 430.000 kronor. Hästen finns i träning hos Kalmaramatören Michelle Eriksson.</p>



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



<figure class="wp-block-image size-sulky-mellan2"><img src="https://sulkysport.se/wp-content/uploads/2022/09/petrisalmela-617x333.jpg" alt="" class="wp-image-352655"/><figcaption class="wp-element-caption">Petri Salmela. Foto Mathias Hedlund/Sulkysport</figcaption></figure>



<p class="has-drop-cap">518 svensktränade hästar fick göra resan över gränsen till finska Torneå igår för att tävla och det stannade vid en blågul seger – tack vare en kanadensisk häst och finskfödd tränare och kusk.</p>



<p>Bodentränaren Petri Salmelas <strong>Robinhood C.A.</strong> (e. Walner) spurtade nämligen hem dagens största lopp, fyra- och femåringsloppet Midnight Race (€12.600), tillsammans med Solvallakusken Mika Forss.<br>Ann-Catrin Frisk-tränade <strong>French Kronos</strong> (e. Face Time Bourbon) och Ove A Lindqvist såg ut att gå mot seger efter attack från andra utvändigt på sista bortre långsidan, men i rygg skuggade hela vägen Robin Hood C.A., som enkelt svepte förbi över upploppet till seger.</p>



<p>Segern var värd 6.000 euro och vinnaren noterade 1.13,1a/2.100 meter.</p>



<p>French Kronos tog andrapriset före Hanna Olofssons <strong>Ja Ba Da Ba Doooo</strong> (e. Donato Hanover), som släppte ledningen efter första sväng och sköt till piggt på upploppet.</p>



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



<p class="has-drop-cap">6Det tävlas på 17 (!) franska banor idag, plus på Karukera i Guadeloupe i Västindien, och det finns svenska inslag.</p>



<p>Markus B Svedberg-tränade fyraåringen <strong>Malcko de Marsac</strong> (e. Hohneck) kommer från seger i tredje försöket i Frankrike när han vann i Bacquevill-en-Caux för två veckor sedan. Nu väntar start i Prix de Sonelec (€15.500) över 2.850 meter i Cartentan, där Tom Beauvais sitter i vagnen.<br>På samma bana plockar Marie Norberg ut <strong>Kendo Jiel</strong> (e. Face Time Bourbon) med sonen Lucas Brohier vid tömmarna. Duon vann tillsammans i slutet av maj.<br>Marie har även <strong>Justess Viking</strong> (e. Ubriaco) till start i Chateau-du-Loir i ett lopp med 19.500 euro i potten.</p>



<p>För Björn Goop blir det dubbla starthästar i Montier-en-Der, där franska duon <strong>Mumbay</strong> (e. Up And Quick) och <strong>Keep Out</strong> (e. Dijon) startar i lopp med 12.500 respektive 16.000 euro i total prispott.<br>Jörgen Westholm-ägde nioåringen <strong>Holster</strong> (e. Bird Parker, som tränas av Ron Kuiper, kommer också ut i Montier-en-Der med tränaren i vagnen.</p>



<p>Jarmo Niskanen tar turen till gräsbanan i Abbeville, där <strong>Maharani</strong> (e. Earl Simon) startar i Prix Bold Eagle (€12.500) över 3.150 meter med Joan Melis Macias i vagnen.</p>



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



<p class="has-drop-cap">7Fem svenska hästägare har klivit över tio miljoner kronor i år och bland dessa finns andelsstallen Ofcourse KB och Easy KB. Toppar med en dryg halvmiljon tillgodo på tvåan Ofcourse gör Stall Zet, där 244 starter givit 55 segrar och 14.569.107 kronor i prispengar.</p>



<p>Paralympiatravsvinnaren <strong>Francesco Zet</strong> (e. Father Patrick) har dragit in mest 2026 med 2,7 miljoner följd av Prix d’Amérique-trean <strong>Epic Kronos</strong> (e. Muscle Hill) på 2,3 och veteranen <strong>Don Fanucci Zet</strong> (e. Hard Livin), 1,6 miljoner.<br>Stall Zet har blivit ägarchampion i Sverige sju av de åtta senaste åren.</p>



<h2 class="wp-block-heading">Sveriges vinstrikaste hästägare 2026</h2>



<p><em>Stall – Starter – Segrar – Prispengar</em></p>



<ol class="wp-block-list">
<li>Stall Zet – 244 – 55 – 14.569.107 kr</li>



<li>Ofcourse KB, Kovland – 956 – 131 – 13.991.463 kr</li>



<li>Easy KB, Uppsala – 985 – 100 – 12.527.812 kr</li>



<li>Stall Courant AB, Heby – 221 – 42 – 10.589.794 kr</li>



<li>Walter-Mommert Karin, Tyskland – 589 – 105 – 10.387.665 kr</li>



<li>SRF Stable – 231 – 40 – 8.604.283 kr</li>



<li>Eagles Rising AB, Bjärred – 23 – 11 – 6.441.500 kr</li>



<li>Mellby Gård AB, Malmö – 103 – 26 – 4.269.740 kr</li>



<li>Göteborg Smart Repair Center AB – 27 – 7 – 3.843.950 kr</li>



<li>Team Westholm AB, Sala – 71 – 13 – 3.424.319 kr</li>
</ol>



<p><em>Statistiken gäller starter på svenska och utländska banor.</em></p>

Fokustema
Sju nyheter vid sju
Läs senare
Nurmos på ”hemmaplan”
Nurmos makalösa facit i Lindesberg. Bergh årsdebuterar svensk rekordhållare. Sista loppen på gräs i Sverige. Fjolårets Kriteriefemma såldes på auktion. Salmelavinst i finskt storlopp. Fem över tio miljoner.
Detta och mer i söndagens ”Sju nyheter vid sju”
Detta och mer i söndagens ”Sju nyheter vid sju”
