
<p class="has-drop-cap">1Det drar ihop sig för Breeeders Crown-semifinalerna på Solvalla den 5 november och ikväll på Axevalla (första start 18.20) är det näst sista chansen att kvala in till semifinal av egen kraft.</p>



<p>Timo Nurmos hade en klang- och jubelföreställning på Solvalla i lördags med segrar i både Svenskt Travkriterium och Oaks, och i Breeders Crown-sammanhang har han varit finalvinnare vid åtta tillfällen:</p>



<ul class="wp-block-list">
<li><strong>Treåriga h/v:</strong> Sahara Dynamite, Yield Boko och Brother Bill</li>



<li><strong>Treåriga ston:</strong> Vala Boko</li>



<li><strong>Fyraåriga h/v:</strong> Sahara Dynamite och Yield Boko</li>



<li><strong>Fyraåriga ston:</strong> Miss Beniss och Lara Boko</li>
</ul>



<p>Till Axevalla ikväll sänder han tre hästar för att säkra platser i årets Breeders Crown-semifinalen. En av dem har faktiskt redan gjort det. Fjolårets Oakstvåa <strong>Aurelia Express</strong> (e. Readly Express) vann ett Breeders Crown-försök på Jägersro för fem veckor sedan och är redan inkvalat till semifinalen för de fyraåriga stona. Hon möter Mattias Djuses <strong>Kayla Westwood</strong> (e. Maharajah), som i år varit tvåa i Drottning Silvias Pokal och fyra i Stosprintern.</p>



<p>Nurmos två andra hästar behöver ordna en semibiljett ikväll. Fyraårige <strong>Miru Boko</strong> (e. Royalty For Love) är en segerstaplare av rang. Åtta starter har givit sex segrar och valacken har aldrig varit sämre än tvåa. I höst har han kommit tillbaka efter drygt nio månaders tävlingsuppehåll och är obesegrad i årets tre starter.<br>Treåriga stoet <strong>Jobiline Ridge</strong> (e. Readly Express) var fyra när hon testades i Oakskval och ställs i BC-försöket mot fjolårets tvåa i Svensk Uppfödningslöpning, <strong>Frustration</strong> (e. Fourth Dimension), som var nära att kvala in till Oaks som trea i sitt försök.</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/05/elitloppet500meter-617x333.jpg" alt="" class="wp-image-308558"/><figcaption class="wp-element-caption">Click Bait i ledning med Hail Mary på utsidan och Mister F.Daag i ledarrygg efter 500 meter i Elitloppet 2021. Foto Mathias Hedlund/Sulkysport</figcaption></figure>



<p class="has-drop-cap">22019 avslutade <strong>Click Bait</strong> (e. Cantab Hall) treåringssäsongen med seger i Eskilstuna i slutet av oktober. Click Bait har vunnit 18 lopp i karriären, men den vinsten är hingstens enda under höstmånaderna september, oktober, november.<br>När den sexfaldige miljonären ikväll startar i sprinterloppet Ullbergs Minne från passande tredjespår har han gjort 18 höststarter i rad utan att vinna. </p>



<p><strong>Click Baits resultat september-november:</strong></p>



<ul class="wp-block-list">
<li>2020: 5 starter – 0 segrar</li>



<li>2021: 5 starter – 0 segrar</li>



<li>2022: 6 starter – 0 segrar</li>



<li>2023: 2 starter – 0 segrar</li>
</ul>



<p>Axevalla travbana hade premiär 1956 och travsällskapets förste ordförande var Johan Ullberg på Lassegården i Öttum. Ullbergs Minne med 100.000 kronor i förstapris körs för 32:a gången och loppet har sett fina vinnare genom åren som <strong>Copiad</strong>, hemmastjärnan <strong>Fridhems Ambra</strong> och <strong>Super Photo Kosmos</strong>.<br>I årets upplaga ställs Click Bait mot hästar som <strong>Heart Of Steel, Ultion Face</strong> och <strong>Unico Broline.</strong></p>



<p>Axevalla är värd för kvällens V64-spel, där det vankas runt 900.000 kronor extra i sexrättspotten sedan utdelningen på fyra rätt i gårdagens favoritbetonade omgång på Färjestad uteblivit.</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/01/amandaceleberkw-617x333.jpg" alt="" class="wp-image-400271"/><figcaption class="wp-element-caption">Amanda Celeber och Kjell Wallin. Foto Stalltz.se</figcaption></figure>



<p class="has-drop-cap">3Själv slutade hon trea i Svenskt Trav-Oaks, femma i Stochampionatet och var även finalist i Breeders Crown i regi Kjell Wallin, men det är i avelsboxen <strong>Amanda Celeber</strong> (e. Express Ride-Judy Tim e. Lindy’s Crown) gjorde de bestående avtrycken. Hennes första avkomma var självaste <strong>Tamla Celeber</strong> (e. Cantab Hall), 1.10,2ak/8.310.666 kr, och följdes bland annat av miljonärerna <strong>Odessa Celeber</strong> (e. Cantab Hall) och <strong>Sidney Celeber</strong> (e. Readly Express).</p>



<p>Nu har Amanda Celeber lämnat jordelivet i en ålder av 23 år. Det berättar Långeruds Gård, där hon levde som fölsto, på sin facebooksida.</p>



<p>Amanda Celeber vann fyra av 47 starter och sprang in 874.000 kronor. För hennes framgångar som fölsto utsågs hon till Diplomsto. Dottern Tamla Celeber för mammas arv vidare på bästa sätt och med blott fyra avkommor hittills i startbar ålder har hon utsetts till Elitsto. Fyrfaldiga miljonärerna <strong>Forfantone Am</strong> (e. Muscle Hill) och <strong>Imhatra Am</strong> (e. Muscle Hill) har gett Tamla en flygande start i avelsboxen.</p>



<p>Amanda Celeber fick sitt sista föl 2021 och den nu tvåårige sonen Xavier Celeber (e. Readly Express) finns i träning hos Öystein Tjomsland.</p>



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



<p class="has-drop-cap">4Tisdagen inleds på svensk mark på Bergsåker (första start 12.20). Jimmy H Andersson plockar ut kapable <strong>Fortune Mearas</strong> (e. Dream Vacation) i comeback efter drygt halvårslång tävlingsfrånvaro. Valacken slutade bland annat fyra i Svensk Uppfödningslöpning 2017 i Svante Båths regi och efter ett år hos Johan Untersteiner köptes han av Jimmy på våren som sexåring. Där har han bland annat tre andraplatser i silverdivisionen bakom sig och vid den sista av dem på december tog han klivet in i gulddivisionen.</p>



<p>Nu har han inte tävlat sedan i påskas i Gävle, där han slutade trea i ett lopp som vanns av <strong>Sourire Frö</strong> (e. Wishing Stone), och i dagens lunchlopp inleder han från 20 meters tillägg i ett sjuhästarsfält.</p>



<p>Eskilstuna (första start 17.45) kompletterar utbudet med breddlopp. </p>



<p><a href="https://sulkysport.se/wp-content/uploads/2023/10/231017.pdf" target="_blank" rel="noreferrer noopener">Här är startlistorna till tisdagens 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/2023/08/janolovpersson2-617x333.jpg" alt="" class="wp-image-478961"/><figcaption class="wp-element-caption">Jan-Olov Persson. Foto Mathias Hedlund/Sulkysport</figcaption></figure>



<p class="has-drop-cap">5Hon har redan vunnit både Kriteriestoet på Dannero och Stokriteriet på Bjerke, men än är inte säsongen över för Jan-Olov Persson-tränade <strong>Majblomster</strong> (e. Tekno Odin). På lördag väntar säsongens sista klassiker för kullens ston när Norskt Oaks ska avgöras på Momarken och Majblomster kan lägga ytterligare en titel till succésäsongen.</p>



<p>De norskfödda varmbloden gör också upp om Oakstiteln och här finns Frode Hamres Stokriterievinnare <strong>Meghan B.R.</strong> (e. Face Time Bourbon) i favoritposition.<br>Oaks för båda raserna avgörs över 2.140 meter med autostart och 300.000 norska kronor till vinnarna.</p>



<h2 class="wp-block-heading">Norskt Trav-Oaks – kallblod</h2>



<ol class="wp-block-list">
<li>Troll Sterk Faksine (e. Tekno Odin) – Jan Roar Mjölneröd</li>



<li>Ada Ö.K. (e. Moe Odin) – Bernt Öksnevad</li>



<li>Majblomster (e. Tekno Odin) – Mats E Djuse (Jan-Olov Persson)</li>



<li>Garli Andrea (e. Bork Odin) – Tom Erik Solberg (Öystein Tjomsland)</li>



<li>Kalani (e. Odd Herakles) – Robert Kruse (Selma Johanne Ekeberg)</li>



<li>Voje Lotta (e. Ängsborken) – Lars Anvar Kolle (Jan Kristian Överdal)</li>



<li>Johanna (e. Särpefanten) – Johan Ole Östre</li>



<li>Fia Med Knuff (e. Tekno Odin) – Eirik Höitomt (Jan-Olov Persson)</li>



<li>Asakblomst (e. Tekno Odin) – Geir Flåten</li>
</ol>



<h2 class="wp-block-heading">Norskt Trav-Oaks – varmblod</h2>



<ol class="wp-block-list">
<li>G.G.Ermita (e. Trixton) – Vidar Hop (Erik Killingmo)</li>



<li>Allegra Avanza (e. Bar Hopping) – Frode Hamre</li>



<li>Meghan B.R. (e. Face Time Bourbon) – Tom Erik Solberg (Frode Hamre)</li>



<li>Spicy Pepper (e. Quite Easy) – Dag-Sveinung Dalen (Rune Flaskerud)</li>



<li>Micah B.R. (e. Maharajah) – Svein Ove Wassberg (Morten Anderssen)</li>



<li>Waterloo Bonanza (e. Sinou Madrik) – Lars Anvar Kolle (Madeleine Larsen)</li>



<li>Nelson Diddi (e. Maharajah) – Åsbjörn Tengsareid (Thor Borg)</li>



<li>Haley James (e. Offshore Dream) – Per Oleg Midtfjeld (Morten Pedersen)</li>



<li>Snap Attack (e. Ens Snapshot) – Mats E Djuse (Anders Lundström Wolden)</li>



<li>Musical Sun (e. Broadway Legs) – Magnus Teien Gundersen (Frode Hamre)</li>



<li>Annabelle (e. Explosive Matter) – Erlend Rennesvik (Anders Lundström Wolden)</li>



<li>She Wolf (e. Yarrah Boko) – Vemund Madsen Drolsum (Tone Britt Madsen)</li>
</ol>



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



<p class="has-drop-cap">6Vincennes (första start kl. 13.50) travar igång sina tisdagstävlingar under senlunchen och det finns gott om blågula intressen. I evakueringsloppet Prix Algorah (€59.000) styrs Christoffer Eriksson-tränade <strong>Hurricane River</strong> (e. Up and Quick) av Yoann Lebourgeois och i samma lopp startar Yannick Henry svenskfödde <strong>Gardner Shaw</strong> (e. Ready Cash) tillsammans med Benjamin Rochard.<br>I det loppet gör därtill en av Norges bästa hästar <strong>Cicero T.G.</strong> (e. Kadabra) debut i Jean-Michel Bazires regi och ”chefen själv” svingar sig upp i vagnen bakom sexåringen, som tävlar barfota runt om direkt. </p>



<p>Tomas Malmqvist bidrar med en duo genom <strong>Kobayahsi</strong> (e. Face Time Bourbon) i Prix Arethusa (€62.000) och <strong>King Stallion</strong> (e. Ready Cash) I Prix Orion (€52.000) och två hästar startar även Jarmo Niskanen.<br>Dels <strong>India Song</strong> (e. Django Riff) i Prix Euterpe (€53.000), men även <strong>Jockstrap</strong> (e. Prince Gede) i Prix Cyrene (€46.000).</p>



<p><a href="https://sulkysport.se/trav-och-galopp/paris-vincennes-2023-10-17/" target="_blank" rel="noreferrer noopener">Här kan du ta del av dagens startlistor till tävlingarna på Vincennes.</a></p>



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



<p class="has-drop-cap">7Fyra svensktränade hästar tar chansen att kvala in till Dansk Uppfödningslöpning ut uttagningarna körs på Charlottenlund ikväll. <br>Tomas Malmqvist startar duon <strong>Karl Halbak</strong> (e. Cash Gamble) och <strong>Keeping the Shadow </strong>(e. Googoo Gaagaa), vilka båda körs av Ken Ecce. Jimmi Ehlers åker från Lindesberg och sitter upp bakom egentränade <strong>Kozmo Simoni </strong>(e. Django Riff), medan Dante Kolgjini kör storebror Adrians <strong>Kilimanjaro Face</strong> (e. Googoo Gaagaa).</p>



<p>De två främsta i försöken är garanterade plats i finalen på Charlottenlund den 5 november. Dessutom går de två högst seedade treorna till final. De två sista platserna är vikta för de två högst rankade i poängberäkningen.</p>



<h2 class="wp-block-heading"><strong>Dansk Uppfödningslöpnin</strong>g</h2>



<p>Tvååringar. <strong>Förstapris:</strong> 20.000 danska kronor.<br><em>2.000 meter, autostart.</em></p>



<p><strong>Försök I:</strong><br><strong>Namn (far) – Körsven</strong></p>



<ol class="wp-block-list">
<li><strong>Kattejammer Cash</strong> (e. Cash and Go) – Kent Friborg</li>



<li><strong>Keeping the Shadow</strong> (e. Googoo Gaagaa) – Ken Ecce</li>



<li><strong>Kuzco</strong> (e. Wishing Stone) – Gordon Dahl</li>



<li><strong>Kajser </strong>(e. Great Challenger) – Casper M Nielsen</li>



<li><strong>Killer Choice</strong> (e. Prodigious) – Rene Kjaer</li>



<li><strong>Kathleen Vincent</strong> (e. Ravenna) – Jörgen Sjunnesson</li>



<li><strong>Kobra Shadow</strong> (e. Dominion Beach) – Jeppe Juel</li>



<li><strong>Kom On Gardenia </strong>(e. Great Challenger) – Knud Mönster</li>
</ol>



<p><strong>Försök II:</strong></p>



<ol class="wp-block-list">
<li><strong>Kennedy</strong> (e. Muscle Mass) – Jeppe Juel</li>



<li><strong>Karisma Gardenia</strong> (e. Dominion Beach) – Sören Johansson</li>



<li><strong>Koko K</strong> (e. Wishing Stone) – Knud Mönster</li>



<li><strong>Kingston Laser</strong> (e. Maharajah) – Casper M Nielsen</li>



<li><strong>Klinton Cloc</strong> (e. Wishing Stone) – Rene Kjaer</li>



<li><strong>Kungfufighting</strong> (e. Nuncio) – Jan Dahlgaard</li>



<li><strong>Kleopatra</strong> (e. Dominion Beach) – Kent Friborg</li>



<li><strong>Kari Halbak</strong> (e. Cash Gamble) – Ken Ecce</li>



<li><strong>Kaliffen</strong> (e. Wishing Stone) – Birger Jörgensen</li>
</ol>



<p><strong>Försök III:</strong></p>



<ol class="wp-block-list">
<li><strong>Kaizen Cash</strong> (e. Cash and Go) – Kent Friborg</li>



<li><strong>Kiwi Shadow</strong> (e. Broad Bahn) – Birger Jörgensen</li>



<li><strong>Kingo Gardenia</strong> (e. Dominion Beach) – Martina Andreasen</li>



<li><strong>Karat C N </strong>(e. Express Bourbon) – Jörgen Sjunnesson</li>



<li><strong>Kozmo Simoni</strong> (e. Django Riff) – Jimmi Ehlers</li>



<li><strong>Kingston Flamingo</strong> (e. Ens Snapshot) – Jeppe Rask</li>



<li><strong>Karlotta By Hans</strong> (e. Donato Hanover) – Bent Svendsen</li>



<li><strong>Kilimanjaro Face</strong> (e. Googoo Gaagaa) – Dante Kolgjini</li>
</ol>



<p><strong>Försök IV:</strong></p>



<ol class="wp-block-list">
<li><strong>Koningin</strong> (e. Great Challenger) – Michael Lönborg</li>



<li><strong>Kesse Tårs</strong> (e. Donato Hanover) – Knud Mönster</li>



<li><strong>Kamille Bakkely</strong> (e. Forever Peace) – Rene Jonassen</li>



<li><strong>Kombardo Skov</strong> (e. Dominon Beach) – Henrik Lönborg</li>



<li><strong>Kanon Laser</strong> (e. One Too Many) – Steen Juul</li>



<li><strong>Kong Hans</strong> (e. Brillantissime) – Bent Svendsen</li>



<li><strong>Kylie By Hans</strong> (e. Googoo Gaagaa) – Jörgen Sjunnesson</li>



<li><strong>Kingoftheroad</strong> (e. Dontpayfortheferryman) – Jan Dahlgaard</li>
</ol>
