
<p class="has-drop-cap wp-block-paragraph">1Axel Jensens Minneslopp för fyraåringar har varit en senhösthöjdare på Bjerke (första start 14.45) för fyraåriga varmblod i många år. Sedan 1986 har grupp II-loppet avgjorts enligt nuvarande format: sprinterdistans, startbil och fyraåriga varmblod.<br>Loppet har sett många starka vinnare och i eftermiddag ska en ny koras. Årets upplaga låter inte skämmas för sig med Sprintermästaren mångmiljonären <strong>Kilmister</strong> (e. Chapter Seven), <strong>Crown</strong> (e. Chapter Seven), norske Derbyvinnaren <strong>Charron</strong> (e. Code Bon), segermaskinen <strong>Killiam Fromentro</strong> (e. Villiam) och Drottningpokalvinnaren <strong>Karaboudjan</strong> (e. Walner) för att nämna en kvintett.</p>



<p class="wp-block-paragraph">Frågan är hur fort det kan travas i årets lopp? Löpningsrekordet står i särklass och delas mellan två vinnare. Adrian Kolgjini styrde <strong>Buzz Mearas</strong> (e. Dream Vacation) till vinst på 1.10,4a/1.609 meter för nio år sedan. Buzz Mearas hade då två veckor tidigare slutat tvåa i Breeders Crown-finalen för fyraåriga hingstar och valacker bakom en viss <strong>Nuncio</strong> (e. Andover Hall).<br>Den tiden tangerade Gennaro Casillo-tränade <strong>Demon</strong> (e. Royal Blessed) tillsammans med Carl Johan Jepson vid förra årets triumf.</p>



<figure class="wp-block-image size-sulky-mellan2"><img src="https://sulkysport.se/wp-content/uploads/2023/07/demoncjj-617x333.jpg" alt="" class="wp-image-472651"/><figcaption class="wp-element-caption">Demon och Carl Johan Jepson. Foto Mathias Hedlund/Sulkysport</figcaption></figure>



<p class="wp-block-paragraph">Just Jepson gör comeback i tävlingssulkyn idag efter drygt två månaders uppehåll på grund av skada.<br>– Det har varit en ständig värk och jag har inte sovit en full natt utan vaknat runt klockan fyra varje morgon, säger han själv i en lång intervju med Sulkysport.</p>



<p class="wp-block-paragraph"><a href="https://sulkysport.se/fokus/jepson-tillbaka-i-sulkyn-inte-sovit-en-full-natt/" target="_blank" rel="noreferrer noopener">Läs hela intervjun här!</a></p>



<h2 class="wp-block-heading">Alla vinnare som travat under 1.12</h2>



<p class="wp-block-paragraph"><em>Segertid – År – Vinnare (far) – Kusk (tränare)</em></p>



<ul class="wp-block-list">
<li>1.10,4a – 2015 – Buzz Mearas (e. Dream Vacation) – Adrian Kolgjini (Lutfi Kolgjini)</li>



<li>1.10,4a – 2023 – Demon (e. Royal Blessed) – Carl Johan Jepson (Gennaro Casillo)</li>



<li>1.11,0a – 2017 – Ferrari B.R. (e. Muscles Yankee) – Per Oleg Midtfjeld</li>



<li>1.11,2a – 2022 – Type A. (e. Southwind Frank) – Magnus Teien Gundersen (Frode Hamre)</li>



<li>1.11,5a – 2016 – Twister Bi (e.Varenne) – Christoffer Eriksson (Jerry Riordan)</li>



<li>1.11,7a – 2014 – Tumble Dust (e. Crazed) – Björn Goop (Tomas Malmqvist)</li>



<li>1.11,8a – 2018 – Vainqueur R.P. (e. Infinitif) – Ulf Ohlsson (Frode Hamre)</li>



<li>1.11,8a – 2021 – Fire n’Fury (e. Explosive Matter) – Mats E Djuse (Stefan Melander)</li>



<li>1.11,9a – 2013 – Stelton (e. Dream Vacation) – Jeppe Juel</li>
</ul>



<p class="wp-block-paragraph"><a href="https://sulkysport.se/wp-content/uploads/2024/10/02v75.pdf" target="_blank" rel="noreferrer noopener">Här är startlistorna till Bjerkes tävlingar.</a></p>



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



<p class="has-drop-cap wp-block-paragraph">2V75 på norsk mark och en del nya hästar dyker upp i startlistorna när fördelningen mellan Norge och Sverige är 41-38 i norsk favör när det gäller V75-hästarnas tränares hemland. Resterande fyra av de totalt 83 hästar som var med i V75-startlistorna är dansktränade (läs: Nicklas Korfitsen).</p>



<p class="wp-block-paragraph">En hel del hästar som inte tidigare mötts ger en annorlunda V75-omgång.<br><em>”På V75-systemet blir det två spikar som utgör grunden mot alla rätt. Vi går ut hårt och spikar <strong>Meghan B.R.</strong> i V75-1 som ska ha en vettig chans oavsett löpningsförlopp. <strong>Crown</strong> vann Sprintermästaren i somras och blir svårslagen i V75-6,”</em> skriver Sulkysports expert.</p>



<p class="wp-block-paragraph">Får vår expert medhåll från tränarhåll? Så här säger Daniel Redén på Stall Zets hemsida angående årets Sprintermästare Crown:<br>– Crown går jämnt och bra. Senast fick han allt kvar över mål så han är bra i ordning och kommer göra ett bra lopp. Han går precis som han brukar så det blir inga ändringar på honom, säger Daniel Redén.</p>



<p class="wp-block-paragraph"><a href="https://sulkysport.se/spelstugan/v75-tips-2-11-kungakronan-sitter-kvar-pa-crown/" target="_blank" rel="noreferrer noopener">Här är hela tipsgenomgången till Bjerke med analyser, spikar, drag och systemförslag.</a></p>



<p class="wp-block-paragraph">Missa inte andelsspelen hos vår samarbetspartner Travnet på Högkvarteret. <br><a href="https://www.atg.se/hogkvarteret/V75_2024-11-02_78_5" target="_blank" rel="noreferrer noopener">Här finns Travnets andelar.</a></p>



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



<figure class="wp-block-image size-sulky-mellan2"><img src="https://sulkysport.se/wp-content/uploads/2021/09/claessjostrom2-617x333.jpg" alt="" class="wp-image-219579"/><figcaption class="wp-element-caption">Claes Sjöström. Foto: Mathias Hedlund/Sulkysport</figcaption></figure>



<p class="has-drop-cap wp-block-paragraph">3Huvudfokus må vara mot Norge och Bjerke denna dag, men svenskarna ligger verkligen inte på latsidan heller. Tre banor bjuder på tävlingar och det drar igång med en årsfinal. I Visby (första start 11.00) är det nämligen dags att sätta punkt för säsongen efter 19 tävlingsdagar på ”ön”.</p>



<p class="wp-block-paragraph">Kuskligan slutar som den brukar, med ett nytt championat för Claes Sjöström. För nionde året i rad, och tolfte gången i karriären, blir Solvallatränaren segerrikaste körsven. 26 segrar har det blviit hittills i år på Gotland, sju fler än tvåan Martin Malmqvist. Fler kan det bli för Sjöström som kör åtta av nio lopp.</p>



<p class="wp-block-paragraph">Bland annat sitter han upp bakom hemmamatören Stefan Admans sto <strong>Kyrkebys</strong> <strong>Lisbet</strong> (e. Fourth Dimension) i Visbytravets treåringsseries final med 60.000 kronor till vinnaren. Kyrkebys Lisbet kommer närmast från seger i ett treåringslopp på Solvalla och har tidigare under säsongen plockat tre vinster på hemmaplan.</p>



<p class="wp-block-paragraph">Även Åby inleder tävlingarna på förmiddagen (första start 11.10) och där står breddlopp på menyn.</p>



<p class="wp-block-paragraph">Lördagen avslutas på Romme (start 18.30), där årets svenska dammästarinna Agnes Larsson kan vinna lärlingsseriens final. Hon kör Markus B Svedberg-tränade <strong>Billy the</strong> <strong>Bronco</strong> (e. Fourth Dimension), som vann STL-lopp i september.</p>



<p class="wp-block-paragraph"><a href="https://sulkysport.se/wp-content/uploads/2024/10/241102.pdf" target="_blank" rel="noreferrer noopener">Här är startlistorna till dagens tävlingar.</a></p>



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



<p class="has-drop-cap wp-block-paragraph">4Fördel ston i Solvallaserien på onsdagar med ett antal försöksomgångar och finaler liknande STL-upplägget har revolutionerats under 2024. Stona har nämligen sedan fördelen gentemot hingstar och valacker – ston får ha tjänat betydligt med än killarna i respektive klass – infördes inför årets säsong ökade både starter, segrar och prispengar enormt i Solvallaseriens tre klasser.</p>



<p class="wp-block-paragraph">ST:s propositionsskrivade Mattias Stenby <a href="https://www.travsport.se/arkiv/nyheter/2024/november/manadsinformation-propositioner-nya-klasser-i-solvallaserien-2025/" target="_blank" rel="noreferrer noopener">redovisar nämligen följande siffror</a> i sitt månadsbrev.</p>



<ul class="wp-block-list">
<li>Antal starter: 17 procent ston 2023 mot 42 procent ston 2024.</li>



<li>Antal segrar: Tre (3) procent av loppen vanns av ston, medan 39 procent vunnits av ston i år.</li>



<li>Prispengar: Åtta procent togs av ston 2023 och i år har stona lagt beslag på 39 procent.</li>
</ul>



<p class="wp-block-paragraph">Från och med nästa meeting justeras klasserna i Solvallaserien – precis som klassinledningen i STL där bland annat klass III gör comeback.</p>



<p class="wp-block-paragraph"><strong>Här är de nya klasserna:</strong><br><strong>Solvallaserien 220</strong> (tidigare högst 150.000 kr): Hingstar och valacker 75.001-220.000 kr, ston högst 320.000 kr<br><strong>Solvallaserien 420</strong> (tidigare högst 350.000 kr): Hingstar och valacker 175.001-420.000 kr, ston högst 620.000 kr<br><strong>Solvallaserien 720</strong> (tidigare högst 650.000 kr): Hingstar och valacker 220.001-720.000 kr, ston högst 1.020.000 kr</p>



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



<figure class="wp-block-image size-sulky-mellan2"><img src="https://sulkysport.se/wp-content/uploads/2024/06/tonyadams1462024lisa-617x346.jpg" alt="" class="wp-image-597016"/><figcaption class="wp-element-caption">Tony Adams (5) vid vinst på Meadowlands. Foto: Lisa Photo</figcaption></figure>



<p class="has-drop-cap wp-block-paragraph">5Svenskfödde <strong>Tony Adams</strong> (e. Muscle Hill-Dreamgirl Hornline), 1.08,4/$392.919, vänder hem efter en framgångsrik sejour hos Åke Svanstedt. Efter 18 starter (5-5-3) blir det Mattias Djuse som får förtroendet att träna Stall Arsenals treåring på svensk mark, <a href="https://www.travronden.se/travsport/handel/hastagande/tranarbyte/a/tony-adams-till-mattias-djuse" target="_blank" rel="noreferrer noopener">skriver Travronden</a>. </p>



<p class="wp-block-paragraph">Tony Adams har finalvunnit New Jersey Classic ($250.000) och Earl Beal Jr. Memorial ($200.000). Det förstnämnda loppet vann han på 1.09,0, men har travat ännu snabbare – 1.08,4 – som tvåa bakom Sig Sauer i en division av Stanley Dancer Memorial. I sin senaste start – finalen i Breeders Crown – slutade Tony Adams nia.<br>Nämnas ska också hans vinster ifjol i en division i John Simpson Sr. Memorial ($42.700) plus försök i Kindergarten Series ($20.000) på Meadowlands.</p>



<p class="wp-block-paragraph">Modern <strong>Dreamgirl Hornline</strong> (e. Ready Cash), 1.13,9am/259.631 kr, har sin andra avkomma i Tony Adams. Själv ingår hon i samma syskonskara som bland andra <strong>Åjo Hornline </strong>(730.650 kr) och <strong>Xray Hornline</strong> (427.227 kr). </p>



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



<p class="has-drop-cap wp-block-paragraph">6Lördagskvällens katalog hos Travera innehåller 37 nummer. Av 15 starthästar USA-födde hingsten <strong>Upstaged</strong> (e. Muscle Hill), som för två år sedan travade 1,10,2ak som tvååring och sprang in nästan 1,5 miljoner kronor. <strong>Nordetia</strong> (e. Propulsion) har vunnit sex av 16 starter och fyraårige <strong>Powhattan U.S. </strong>(e. Muscle Hill) är lillebror till Propulsion.</p>



<p class="wp-block-paragraph">Fölstona dominerar annars i antal med 17, varav åtta är dräktiga. Ett av dem väntar föl med Prix d’Amérique-vinnaren <strong>Idao de Tillard</strong>.<br>På unghästsidan finns tre ettåringar (e. Django Riff, Who’s Who och Tobin Kronos), samt en tvååring med Spartan Kronos som far.</p>



<p class="wp-block-paragraph">Dessutom säljs en betäckning 2025 med <strong>Greenshoe</strong>.</p>



<p class="wp-block-paragraph"><a href="https://www.travera.nu/kopa-hast/" target="_blank" rel="noreferrer noopener">Här går det att se hästarna som bjuds ut och följa budgivningen under kvällen.</a></p>



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



<p class="has-drop-cap wp-block-paragraph">7Ikväll – första start klockan 19.15 – bjuder Victoria Park i Wolvega på flera topplopp, finalerna i TCT Derby för treåringar, men också på holländsk uppfödningslöpning Productendraverij (€31.900) för tvååringar. </p>



<p class="wp-block-paragraph">Snabbast av försöksvinnarna i den öppna finalen i TCT Derby (€110.000) var <strong>Onana</strong> <strong>Boko</strong> på 1.14,2a/2.100 meter, medan <strong>Force of Nature</strong> noterade 1.14,8. </p>



<p class="wp-block-paragraph">Dubbla försök hölls också i TCT Filly Derby (€55.000) och de vanns av <strong>Olivia W Boko</strong> och <strong>Onmyway Fortuna</strong> på 1.16,3a respektive 1.14,3a/2.000 meter. </p>



<p class="wp-block-paragraph">Vinnarna i såväl Jonkerprijs (€17.050) som Jofferprijs (€16.500) startar i Productendraverij, <strong>Paul Schermer</strong> respektive <strong>Pehoe Boko</strong>.</p>



<p class="wp-block-paragraph"><strong>TCT Derby (€110.000), treåringar.</strong><br>2.100 meter, autostart. <br><em>Namn (far) – Körsven</em></p>



<ol class="wp-block-list">
<li>Force of Nature (e. Brillantissime) – Robbin Bot</li>



<li>Omerta Boko (e. Face Time Bourbon) – Michel Rothengatter</li>



<li>Orion Dragon (e. International Moni) – Micha Brouwer</li>



<li>Onana Boko (e. Trixton) – Dion Tesselaar</li>



<li>Once Again (e. Cash Gamble) – Jaap van Rijn</li>



<li>Odyssey Boko (e. E L Titan) – Christophe Martens</li>



<li>Oliver Kite (e. Offshore Dream) – Jim Veldman</li>



<li>Otis Dream (e. Broadway Fortuna) – Danny Brouwer</li>



<li>Olympus Dragon (e. Propulsion) – Jeffrey Mieras</li>



<li>Olivia Bourbon (e. Face Time Bourbon) – Robin Bakker</li>



<li>Summermusic’night (e. Tactical Landing) – Marciano Hauber</li>
</ol>



<p class="wp-block-paragraph"><strong>TCT Filly Derby (€55.000), treåriga ston.</strong><br>2.100 meter, autostart.</p>



<ol class="wp-block-list">
<li>Oreal Boko (e. International Moni) – Dion Tesselaar</li>



<li>Onymway Fortuna (e. Propulsion) – Robin Bakker</li>



<li>Olivia W Boko (e. Donato Hanover) – Jeffrey Mieras</li>



<li>Oh Marie (e. Propulsion) – Rob van Toor</li>



<li>Opal Stone (e. Charly du Noyer) – Bas Crebas</li>



<li>Olivia Hazelaar (e. Hans Hazelaar) – Jim Veldman</li>



<li>Ophelia Renka (e. Royalty For Life) – Jaap van Rijn</li>



<li>Olympia Greenwood (e. Eridan) – Marciano Hauber</li>



<li>Lisbeth Dry (e. Trixton) – Michel Rothengatter</li>



<li>O’Hara Boko (e. Robert Bi) – Micha Brouwer</li>



<li>Freccia (e. International Moni) – Christophe Martens</li>



<li>Olivia Dragon (e. Six Pack) – John Dekker</li>
</ol>



<p class="wp-block-paragraph"><strong>Productendraverij (€31.900), tvååringar.</strong><br>1.609 meter, autostart. </p>



<ol class="wp-block-list">
<li>Prishana Boko (e. Readly Express) – Robbin Bot</li>



<li>Pavarotti’s Wish (e. Offshore Dream) – Bas Crebas</li>



<li>Pleasure Transs R (e. Brillantissime) – Danny Brouwer</li>



<li>Paul Schermer (e. Tactical Landing) – Erwin Bot</li>



<li>Peshtigo River (e. Muscle Mass) – Dion Tesselaar</li>



<li>Pomona Flevo (e. Cantab Hall) – Marciano Hauber</li>



<li>Malo Renka TF (e. Alto de Viette) – John Dekker</li>



<li>Pehoe Boko (e. Kadabra) – Jeffrey Mieras</li>



<li>Pacific Way (e. Conway Hall) – Niels Jongejans </li>



<li>Pastor Pete (e. Indigious) – Robin Bakker</li>



<li>Mink Boko TF (e. Helgafell) – Micha Brouwer</li>



<li>Perfect Girl Boko (e. Yarrah Boko) – Jim Veldman</li>



<li>Milo Renka TF (e. Brillantissime) – Johan van der Wal</li>
</ol>

Fokustema
Sju nyheter vid sju
Läs senare
Sprintermästare i sprinterfest
Snabbaste vinnarna i Axel Jensens Minne. Sprintermästare mot meriterade konkurrenter. Nionde raka för Sjöström. Stonas enorma frammarsch i Solvallaserien. 1.08-travare tillbaka i Sverige. Miljonlopp i Holland. Propulsions lillebror till salu.
Detta och mer i lördagens nyhetssvep.
Detta och mer i lördagens nyhetssvep.
