
<p>Daniel Redén blev tidernas vinstrikaste tränare i Sverige förra året och blev den förste att passera 54 miljoner kronor som tränare under ett år. Efter framgångar i Frankrike i början av året med <strong>Epic Kronos</strong> tredjeplats i Prix d’Amérique som främsta merit 2026 lät första segern vänta på sig ända till slutet av mars.</p>



<p>Sedan dess har han växlat upp rejält och när <strong>Allegiant</strong> skar mållinjen som vinnare i Elitloppet var det Redéns 52 vinnare på drygt två månader. Segerchecken på fem miljoner kronor ordnade också ett rejält ryck i toppen av tränarligan där han tagit över täten i maj. Redén har placerat sig som bäst fyra i Sulkysports topplistor vid varje månads utgång.</p>



<p>När det gäller inkört per start är förstås Redén också i topp. Hans hästar har snittat 83.470 kronor per start hittills i år.<br>Vasst snitt visar även Timo Nurmos upp med 66.421 kronor per start. </p>



<figure class="wp-block-image size-sulky-mellan2"><img src="https://sulkysport.se/wp-content/uploads/2026/05/12gainingexperiencepris2-617x333.jpg" alt="" class="wp-image-856386"/><figcaption class="wp-element-caption">Timo Nurmos och Björn Goop efter miljonsegern i Harper Hanovers lopp. Foto Mathias Hedlund/Sulkysport</figcaption></figure>



<h2 class="wp-block-heading">Sveriges vinstrikaste tränare 2026</h2>



<p><em>Tränare (placering i tränarligan) – Starter – Segrar – Prispengar – Snitt per start</em></p>



<ol class="wp-block-list">
<li>Daniel Redén (1) – 232 – 52 – 19.365.215 – 83.470 kr</li>



<li>Timo Nurmos (12) – 84 – 34 – 5.579.416 – 66.421 kr</li>



<li>Alessandro Gocciadoro (7) – 139 – 29 – 8.579.075 – 61.720 kr</li>



<li>Paul Hagoort (21) – 63 – 25 – 3.447.406 – 54.720 kr</li>



<li>Daniel Wäjersten (3) – 298 – 77 – 39.607 kr</li>



<li>Lutfi Kolgjini, B-tränare (48) – 34 – 7 – 1.345.550 – 39.675 kr</li>



<li>Maria Törnqvist (14) – 138 – 36 – 5.017.668 – 36.359 kr</li>



<li>Jörgen Westholm (4) – 326 – 47 – 11.608.246 – 35.608 kr</li>



<li>Fredrik Wallin (8) – 211 – 29 – 7.102.766 – 33.662 kr</li>



<li>Claes Sjöström (13) – 156 – 35 – 5.214.250 – 33.424 kr</li>
</ol>



<p><em>Statistiken gäller starter både i Sverige och utomlands till och med 31 maj för landets 50 vinstrikaste tränare.</em></p>



<h2 class="wp-block-heading">Kihlström rusade upp i topp</h2>



<p>Tia i landet  när det gäller antalet segrar, men nummer ett i prispengar. Örjan Kihlström körde in mest pengar under Elitloppshelgen. 6.751.000 kronor blev det inkört för Elitloppsvinnande Kihlström under lördagen och söndag på Solvalla.<br>Med den summan i grunden kliver han upp i topp bland landets kuskar när det gäller inkörda prispengar.</p>



<figure class="wp-block-image size-sulky-mellan2"><img src="https://sulkysport.se/wp-content/uploads/2026/05/11dreamminetvaa-617x333.jpg" alt="" class="wp-image-856588"/><figcaption class="wp-element-caption">Dream Mine och Mats E Djuse vann striden om andraplatsen i Elitloppet. Foto Mathias Hedlund/Sulkysport</figcaption></figure>



<p>Mats E Djuse leder allsvenska körsvensligan i stor stil – 33 vinster fler än lillebror Magnus och ytterligare två före fjolårets champion Carl Johan Jepson – och i prispengar är han närmast bakom Kihlström efter andraplatsen med Dream Mine i Elitloppet.</p>



<h2 class="wp-block-heading">Vinstrikaste kuskar i Sverige 2026</h2>



<p><em>Kusk – Starter – Segrar – Segerprocent – Inkört</em></p>



<ol class="wp-block-list">
<li>Örjan Kihlström – 307 – 49 – 16,0% – 17.469.950 kr</li>



<li>Mats E Djuse – 742 – 145 – 19,5% – 16.933.850 kr</li>



<li>Carl Johan Jepson – 530 – 110 – 20,8% – 16.638.450 kr</li>



<li>Magnus A Djuse – 558 – 112 – 20,1% – 16.326.200 kr</li>



<li>Björn Goop – 460 – 64 – 13,9% – 14.494.800 kr</li>



<li>Ulf Ohlsson – 675 – 85 – 12,6% – 9.356.050 kr</li>



<li>Rikard N Skoglund – 575 – 65 – 11,3% – 9.316.650 kr</li>



<li>Claes Sjöström – 365 – 48 – 13,2% – 8.241.000 kr</li>



<li>Johan Untersteiner – 276 – 78 – 28,3% – 7.552.025 kr</li>



<li>Stefan Persson – 492 – 65 – 7.186.500 kr</li>
</ol>



<p><em>Statistiken gäller starter i Sverige till och med 31 maj.</em></p>



<h2 class="wp-block-heading">Kolgjini bäste amatör!</h2>



<p><strong>I övrigt i topplistorna noteras att:</strong></p>



<p class="has-drop-cap">Lutfi Kolgjini är Sveriges bästa amatörtränare! Det forna Jägersroproffset har börjat tävla med hästar med B-licens i bakfickan och tio av hans 17 hästar på träningslistan är tre år och äldre. De stora prischeckarna i år kom alla under maj månad, där <strong>Barack Face</strong> (e. Ready Cash) vann Milemästaren i Tingsryd och <strong>Gomari</strong> (e. Raja Mirchi) försök till Breeders Crown. Toppstammade stoet <strong>Milady Josselyn</strong> (e. Ready Cash) tog största checken – 375.000 kronor – som trea i Drottning Silvias Pokal.</p>



<figure class="wp-block-image size-sulky-mellan2"><img src="https://sulkysport.se/wp-content/uploads/2020/05/kolgjinilutfisulky-617x333.jpg" alt="" class="wp-image-91472"/><figcaption class="wp-element-caption">Lutfi Kolgjini. Foto Mia Törnberg/Sulkysport</figcaption></figure>



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



<p class="has-drop-cap">Jan-Olov Persson fick inte se något av sina kallblod vinna Elitkampen i år heller – senaste tränarsegern togs med Lome Brage 2018 – men hade ändå en framgångsrik Elitloppsdag när Sveriges snabbaste sto <strong>Majblomster</strong> (e. Tekno Odin) sänkte personbästat till 1.19,6a som tvåa i loppet, tätt före stallkamraten <strong>B.W.Sture</strong> (e. Moe Odin). 750.000 kronor blev den sammanlagda utdelningen för Persson-duon.</p>



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



<p class="has-drop-cap">Jonathan Carre sitter säkert på montétronen och vinner nästan varannan uppsittning på svensk mark, 24 segrar på 50 starter. Fast högre segerprocent har faktiskt gårdagens vinnare av Montéeliten Emilia Leo, som segrar i sju av 13 starter (53,8 procent).</p>



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



<p class="has-drop-cap">Ove A Lindqvist travar på i ohotad ledning bland kuskar med B-licens. 21 vinster har det blivit under årets fem första månader. Tvåan Micael Stjernström har vunnit åtta.</p>



<p>Här är topplistorna per den 31 maj.</p>



<h2 class="wp-block-heading">Segerrikaste kuskar</h2>



<p><em>Kusk, hemmabana (förra månaden) – Starter – Segrar – Inkört</em></p>



<ol class="wp-block-list">
<li>Mats E Djuse, Hagmyren (1) – 742 – 145 – 16.933.850 kr</li>



<li>Magnus A Djuse, Solvalla (2) – 558 – 112 – 16.326.200 kr</li>



<li>Carl Johan Jepson, Färjestad (3) – 530 – 110 – 16.638.450 kr</li>



<li>Ulf Ohlsson, Solvalla (4) – 675 – 85 – 9.356.050 kr</li>



<li>Johan Untersteiner, Halmstad (5) – 276 – 78 – 7.552.025 kr</li>
</ol>



<h2 class="wp-block-heading">Segerrikaste kuskar (B-licens)</h2>



<p><em>Körsven, hemmabana (förra månaden) – Starter – Segrar – Inkört</em></p>



<ol class="wp-block-list">
<li>Ove A Lindqvist, Boden (1) – 153 – 21 – 1.464.950 kr</li>



<li>Micael Stjernström, Mantorp (2) – 86 – 8 – 557.900 kr</li>



<li>Valentin Prevost, Halmstad (3) – 83 – 6 – 769.100 kr</li>



<li>Per Nilsson, Färjestad (ny) – 59 – 6 – 407.700 kr</li>



<li>Hans Bergh, Bergsåker (ny) – 49 – 6 – 404.300 kr</li>
</ol>



<h2 class="wp-block-heading">Segerrikaste montéryttare</h2>



<p><em>Ryttare, hemmabana (förra månaden) – Starter – Segrar – Inridit</em></p>



<ol class="wp-block-list">
<li>Jonathan Carre, Åby (1) – 50 – 24 – 1.306.700 kr</li>



<li>Saga Laursen, Axevalla (2) – 44 – 7 – 560.700 kr</li>



<li>Emilia Leo, Axevalla (ny) – 13 – 7 – 576.400 kr</li>



<li>Jennifer Persson, Solvalla (3) – 29 – 5 – 447.600 kr</li>



<li>Tova Bengtsson, Åby (ny) – 19 – 4 – 310.800 kr</li>
</ol>



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



<figure class="wp-block-image size-sulky-mellan2"><img src="https://sulkysport.se/wp-content/uploads/2023/08/janolovpersson3-617x333.jpg" alt="" class="wp-image-478962"/><figcaption class="wp-element-caption">Jan-Olov Persson. Foto Mathias Hedlund/Sulkysport</figcaption></figure>



<h2 class="wp-block-heading">Vinstrikaste proffstränare</h2>



<p><em>Tränare, hemmabana (förra månaden) – Starter – Segrar – Prispengar</em></p>



<ol class="wp-block-list">
<li>Daniel Redén, Solvalla (4) – 232 – 52 – 19.365.215 kr</li>



<li>Johan Untersteiner, Halmstad (1) – 432 – 102 – 12.378.379 kr</li>



<li>Daniel Wäjersten, Bergsåker (2) – 298 – 77 – 11.802.882 kr</li>



<li>Jörgen Westholm, Solvalla (ny) – 326 – 47 – 11.608.246 kr</li>



<li>Mattias Djuse, Solvalla (3) – 329 – 66 – 9.109.698 kr</li>
</ol>



<h2 class="wp-block-heading">Vinstrikaste kallblodstränare</h2>



<p><em>Tränare, hemmabana (förra månaden) – Starter – Segrar – Prispengar</em></p>



<ol class="wp-block-list">
<li>Jan-Olov Persson, Hagmyren (1) – 309 – 67 – 5.424.999 kr</li>



<li>Robert Skoglund, Bergsåker (2) – 69 – 14 – 973.890 kr</li>



<li>Jan Ove Olden, Hagmyren (3) – 68 – 7 – 703.200 kr</li>



<li>Öystein Tjomsland, Bergsåker (4) – 47 – 6 – 557.248 kr</li>



<li>Jan-Olov Åberg, Bollnäs (ny) – 65 – 5 – 550.500 kr</li>
</ol>



<h2 class="wp-block-heading">Vinstrikaste B-tränare</h2>



<p><em>Tränare, hemmabana (förra månaden) – Starter – Segrar – Prispengar</em></p>



<ol class="wp-block-list">
<li>Lutfi Kolgjini, Jägersro (ny) – 34 – 7 – 1.345.550 kr</li>



<li>Elisabeth Almheden, Kalmar (1) – 15 – 6 – 1.286.000 kr</li>



<li>Hanna Lähdekorpi, Halmstad (2) – 77 – 8 – 1.247.386 kr</li>



<li>Heikko Matias Koskela, Solvalla (ny) – 34 – 4 – 918.100 kr</li>



<li>Angelica Jonsson, Axevalla (ny) – 21 – 5 – 880.900 kr</li>
</ol>



<p><em>Statistiken gäller för starter både i Sverige och utomlands.</em></p>
