
<p class="has-drop-cap">1Preben Söviks norskfödde fyraåring <strong>Just Perfect Sisu</strong> (e. Brillantissime) har en toppsäsong med andraplatsen i Norskt Travderby och segern i Jarlsberg Grand Prix (norska motsvarigheten till Sprintermästaren) på meritlistan. Efter att ha slutat oplacerad i Breeders Crown-semifinalen på Solvalla i början av november är Just Perfect Sisu tillbaka på banan igen kväll på Jägersro (första start 18.20) – och det i en ny gren!</p>



<p>Tillsammans med Sveriges ryttaretta Jonathan Carre väntar nämligen start i julmontén med 50.000 kronor i förstaris för Just Perfect Sisu.<br>Bland motståndarna finns Nicklas Dyrbergs <strong>Kung Edward</strong> (e. Orlando Vici), som vunnit fem montélopp under året och som vanligt rids av Nicole Marsing.</p>



<p>Kort distans och startbil är förutsättningarna i ett lopp för hästar med närmare miljonen kronor insprunget och Lars I Nilsson-tränade <strong>Aramis Face</strong> (e. Raja Mirchi) har bra förutsättningar från spår tre i andra starten efter halvårslångt tävlingsuppehåll. I återkomsten fick han gå stentufft i ledningen och galopperade till slut, men har han tagit den genomköraren på rätt sätt finns chans till snabb revansch.</p>



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



<figure class="wp-block-image size-sulky-mellan2"><img src="https://sulkysport.se/wp-content/uploads/2023/12/majblomstermal-617x333.jpg" alt="" class="wp-image-535157"/><figcaption class="wp-element-caption">Jan-Olov Persson-tränade Majblomster och Mats E Djuse. Foto ALN</figcaption></figure>



<p class="has-drop-cap">2Fem nya namn har tagit plats i de svenska rekordrullorna för kallblod i år. Tre av dem kommer från Jan-Olov Perssons stall, en tränas av Skellefteås Jerker Bjurman och den femte är norsktränad av Andreas Opheim.</p>



<p>Det stora namnet bland de svenskfödda är treåriga stoet <strong>Majblomster</strong> (e. Tekno Odin), som vann Kriteriestoet på Dannero på nya svenska rekordet 1.26,4a/2.140 meter tillsammans med Mats E Djuse.<br>Men det var ingen mot vad som komma skulle en dryg månad senare i finalen av norska Stokriteriet på Bjerke. Där dundrade Majblomster runt på nya världsrekordet 1.23,6a/2.100 meter.</p>



<h2 class="wp-block-heading">Här är listan över nya svenska rekordhållare 2023 – kallblod</h2>



<p><em>(Gäller rekord satta på svenska banor)</em></p>



<p><strong>Treåriga ston:</strong></p>



<ul class="wp-block-list">
<li><strong>Majblomster</strong> (e. Tekno Odin-Järvsö Blomster) – Mats E Djuse<br>1.26,4a/2.140 meter – Dannero 6 augusti. Tränare: Jan-Olov Persson</li>
</ul>



<p><strong>Fyraåriga hingstar/valacker:</strong></p>



<ul class="wp-block-list">
<li><strong>Envis</strong> (e. Lome Brage-Lax Vilja) – Mats E Djuse<br>1.25,9a/2.640 meter – Bergsåker 12 maj. Tränare: Jan-Olov Persson</li>



<li><strong>Juni Blixt</strong> (e. Tekno Odin-Juni Fax) – Mats E Djuse<br>1.24,2/1.680 meter – Gävle 26 oktober. Tränare: Jan-Olov Persson</li>
</ul>



<p><strong>Fyraåriga ston: </strong></p>



<ul class="wp-block-list">
<li><strong>Sonja Kiro</strong> (e. Åsajerven-Odile Kiro) – Stefan Johansson<br>1.25,6/1.700 meter – Skellefteå 14 augusti. Tränare: Jerker Bjurman</li>
</ul>



<p>Sexåriga och äldre utländska hingstar/valacker:</p>



<ul class="wp-block-list">
<li><strong>Ramstad Balder</strong> (e. Norheim Faksen-Lia Topsa – Adrian Solberg Akselsen<br>1.21,3/1.660 meter – Rättvik 5 augusti. Tränare: Andreas Opheim.</li>
</ul>



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



<p class="has-drop-cap">3Breeders Crown-vinnaren <strong>A Fair Day</strong> (e. Maharajah), kallblodsstjärnan <strong>Bäcklös Uriel</strong> (e. Smedheim Solan) och lördagens gulddivisionsvinnare <strong>High On Pepper</strong> (e. Ready Cash) är segerrikaste travarna på svensk mark i år med nio vinster vardera. Bakom skuggar en sextett på åtta årssegrar. En av dessa är Anders Svanstedt-tränade <strong>Putte</strong> (e. S.J.’s Caviar).</p>



<p>När hemmabanan Axevalla (första start 12.20) är tisdagens lunchbana kan Putte kliva upp i delad ledning om det räcker hela vägen till vinst för fyraåringen. Det handlar om spårtrappor över nästan hela linjen på Axevalla (ett nollopp kompletterar) och Putte kommer ut i loppet för de rikaste. Han ställs bland annat mot miljonärerna <strong>Tabasco C.D. </strong>(e. Wishing Stone), <strong>King Of Greenwood</strong> (e. Russel November) och <strong>Sato</strong> (e. Gift Kronos).</p>



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



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



<p class="has-drop-cap">441,2 miljoner kronor ligger redan i sjurättspotten till den multijackpot på Axevalla på nyårsafton som avslutar travspelåret 2023. Potten fylldes på rejält i lördags när utdelningen på fem rätt uteblev i Bollnäs V75-omgång och hela den potten gick direkt in i nyårsaftonens sjurättspott. Ifjol fanns det ”bara” 15,8 miljoner extra i potten.</p>



<p>Från den 25 december blir det V75-spel varje dag och totalt ska åtta V75-omgångar hållas innan multijackpotten på Axevalla.</p>



<p><strong>Här är V75-schemat resten av året:</strong></p>



<ul class="wp-block-list">
<li>23 december: Mantorp – <a href="https://sulkysport.se/wp-content/uploads/2023/12/23v75.pdf" target="_blank" rel="noreferrer noopener">startlistor här!</a></li>



<li>25 december: Umåker – <a href="https://sulkysport.se/wp-content/uploads/2023/12/25v75.pdf" target="_blank" rel="noreferrer noopener">startlistor här!</a></li>



<li>26 december: Solvalla (STL-finaler)</li>



<li>27 december: Momarken</li>



<li>28 december: Skive</li>



<li>29 december: Bjerke</li>



<li>30 december: Gävle</li>



<li>31 december: Axevalla (Sylvesterloppet)</li>
</ul>



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



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



<p class="has-drop-cap">5Efter ett träningsjobb på cirka 1.12,7/1.600 meter på Florens travbana i söndags vänder Gennaro Casillo blickarna mot Paris och start i Prix d’Amérique sista söndagen i januari med norske världsstjärnan <strong>Cokstile</strong> (e. Quite Easy). Det rapporterar italienska travsajten <a href="http://Equos.it">Equos.it</a>. <br>Cokstile travade i rygg på en stallkamrat i träningsjobbet, men släpptes av när denne galopperade i sista kurvan. 1.11 visade klockan sista kilometern enligt Equos.</p>



<p>Den närmaste planen är start i ett något av de återstående B-loppen, Prix de Bourgogne den 31 december eller Prix de Belgique den 14 januari.</p>



<p>Cokstile har varit med i Prix d’Amérique de två senaste åren, men gått lottlös från båda starterna. Totalt har hingsten vunnit 29 lopp och de största har kommit i Elitloppet 2020 samt i VM-loppet på Yonkers Raceway förra hösten. Han startade senast i försök och final av Kommunloppet i Montegiorgio, där han slutade trea i försöket och oplacerad i finalen.</p>



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



<p class="has-drop-cap">6Carl Johan Jepson eller Magnus A Djuse var frågan i kampen om kuskchampionatet i Örebro. Svaret blev Jepson, som definitivt säkrade titeln när han vann med Bengt Berg-tränade <strong>Zenato</strong> (e. Gift Kronos) efter en rejäl avslutning.<br>– Magnus hade chansen att komma ikapp, men jag hade siktat in mig på att vinna ett lopp och nu blev det två, sade en belåten Carl Johan Jepson.<br>18 segrar blev det för Jepson på Närkebanan, där han tog sitt första kuskchampionat. Tränarchampion blev Daniel Redén, vars hästar vann tolv av 24 starter i Örebro.</p>



<p>I söndags slog Kalmartravet igen för säsongen och regerande champion Stefan Persson försvarade titeln ”i kavaj”, då han inte körde årsfinalen. 29 segrar blev det under året, tre fler än tvåan Joakim Lövgren. Stefan har därmed blivit Kalmarchamp fyra år i rad.<br>Jägersrotränare Lövgren blev istället segerrikaste tränare med 29 triumfer. Johan Untersteiner plockade hem 27. Lövgren var även ensam om att kliva över två miljoner till stallet under 2023.</p>



<h2 class="wp-block-heading">Svenska banchampions 2023</h2>



<p><em>Bana – Kusk, hemmabana – Segrar</em></p>



<ul class="wp-block-list">
<li>Arvika – Björn Goop, Färjestad – 6</li>



<li>Dannero – Henrik Svensson, Bergsåker – 10</li>



<li>Hagmyren – Mats E Djuse, Hagmyren – 18</li>



<li>Halmstad – Johan Untersteiner, Halmstad – 47</li>



<li>Hoting – Rikard N Skoglund, Solvalla – 5</li>



<li>Kalmar – Stefan Persson, Halmstad – 29</li>



<li>Karlshamn – Peter Untersteiner, Halmstad – 5</li>



<li>Lindesberg – Magnus A Djuse, Solvalla – 11</li>



<li>Lycksele – John Östman, Umåker – 4</li>



<li>Oviken – Jan-Olof Johansson, Östersund – 3</li>



<li>Rättvik – Magnus A Djuse, Solvalla – 14</li>



<li>Skellefteå – Stefan Johansson, Umåker – 14</li>



<li>Solänget – Henrik Svensson, Bergsåker – 7</li>



<li>Tingsryd – Christian Cracchiolo, Halmstad – 4</li>



<li>Vaggeryd – Stefan Persson, Halmstad – 12</li>



<li>Visby – Claes Sjöström, Solvalla – 31</li>



<li>Åmål – Björn Goop, Färjestad – 11</li>



<li>Årjäng – Magnus Jakobsson, Färjestad – 11</li>



<li>Örebro – Carl Johan Jepson, Färjestad – 18</li>
</ul>



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



<p class="has-drop-cap">7De tre första säsongerna på tävlingsbanan resulterade en seger per år. 2023 har den i Finland tävlande svenskfödde <strong>Mandela Zon</strong> (e. Maharajah) vunnit 25 lopp! Och än är segerjakten inte över – ikväll tävlar han i Tammerfors och på lördag går turen till Uleåborg.</p>



<p>Reima Kuisla, som firade stora framgångar som ägare till <strong>Etain Royal</strong> (61 segrar och 1.435.474 euro i prispengar), både tränar och äger Mandela Zon. Sexåringen har tävlat flitigt under året och redan hunnit med 39 starter (25-9-0) och sprungit in över 125.000 euro. Mandela Zon har oftast tävlat för sulky, men största segern kom under sadel när han en monté-final i Björneborg den 1 december värd 14.000 euro.<br>1.500 euro ligger i potten i kvällens lopp, där en hel del svenskbekantingar står för motståndet. Bland annat plockar Katja Melkko ut <strong>Mas Capacity</strong> (e. Conway Hall), som jagar första årssegern.</p>



<p><strong>Startlista, Tammerfors tisdag</strong><br><em>2.100 meter voltstart, förstapris 1.500 euro:</em></p>



<ol class="wp-block-list">
<li>Very Gone Face (e. Joke Face) – Hannu Kamppuri</li>



<li>Dartboard (e. Maharajah) – Olli Koivunen<br><em>2.120 meter:</em></li>



<li>Mandela Zon (e. Maharajah) – Ari Moilanen</li>



<li>Payet (e. Main Wise As) – Juha Utala</li>



<li>Dust Collector (e. Dust All Over) – Esa Holopainen</li>



<li>Van Kronos (e. Timoko) – Jarmo Saarela</li>



<li>Grainfield Aiden (e. Andover Hall) – Hannu Korpi</li>



<li>Pope (e. Like A Prayer) – Tuukka Varis</li>



<li>Justice Ås (e. Justice Hall) – Seppo Markkula</li>



<li>Mas Capacity (e. Conway Hall) – Antti Teivainen</li>



<li>Way To Go (e. Le Monteil) – Tino Keväänranta</li>



<li>Issaquah Sund (e. Offshore Dream) – Marko Myyryläinen</li>
</ol>

Fokustema
Morgonsvepet
Läs senare
Derbytvåa testar monté
Ny gren för årets Derbytvåa. Kallbloden som tog plats i rekordrullorna. Så mycket ligger i potten på nyårsafton. Norsk stjärna mot Prix d’Amérique igen. Svensk häst jagar seger 26 – i år!
Detta och mer i tisdagens ”Sju nyheter vid sju”.
Detta och mer i tisdagens ”Sju nyheter vid sju”.
