
<p class="has-drop-cap wp-block-paragraph">1Den 17 augusti 1964 gick Big Noon ur tiden på Menhammar Stuteri. Innan dess hade Big Noon uträttat mycket på tävlingsbanan och som avelshingst, men också varit på väg att fastna i nazisternas klor när han var och tävlade i Berlin under brinnande världskrig 1942 i dåtidens största europeiska löpning Matadoren-Rennen på den sedan länge nerlagda Ruhleben-banan i Berlin.</p>



<p class="wp-block-paragraph">Tyskarna ville helt enkelt inte lämna ifrån sig den svenska stjärnhästen eftersom den som hade högsta befälet över travsport i Tredje riket – Christian Weber – hade fattat tycke för Big Noon.</p>



<figure class="wp-block-image size-sulky-mellan2"><img src="https://sulkysport.se/wp-content/uploads/2020/10/bignoon3-617x392.jpg" alt="" class="wp-image-117311"/><figcaption class="wp-element-caption">Big Noon. Foto Knut Andersen</figcaption></figure>



<p class="wp-block-paragraph">Signaturen Bo ”Red Mile” Fransson har skrivit historien om turerna runt Big Noons start i dåtidens största europeiska löpning Matadoren-Rennen på den sedan länge nerlagda Ruhleben-banan i Berlin och den svenska klenmodigheten mot Tredje riket. Big Noon kom så småningom hem till Sverige, eller som saken uttrycktes av ”Red Mile”:<br><em>”Den enda gången det svenska lejonet röt hos nazismens utrikesminister Joakim von Ribbentrop, under Andra världskrigets sex år&#8230;då gällde det en travhäst!”</em></p>


<div class="factbox left minify">
<div class="insidefactbox">
<div class="overflow">
<div class="height">
<div class="padding">
<div class="factvinjett">Fakta</div>
<h3 class="title">
									Big Noon								</h3>
<div class="content">
<p class="wp-block-paragraph">Hingst född 1936 e. High Noon-My Sister Lou e. Peter the Great. Död 17 augusti 1964.<br /><strong>Rekord:</strong> 1.18,3k* <br /><strong>Prissumma:</strong> 99.112 kr <br /><strong>Resultat:</strong> 79 st: 49-9-8 <br /><strong>Ägare:</strong> Stall Segerhuva, Stockholm <br /><strong>Uppfödare:</strong> Reinhold Mattsson, Kvarnbille <br /><strong>Tränare &amp; körsven:</strong> Gösta Nordin, Solvalla<br /><strong>Större meriter: </strong>Åby Stora Pris 1941, Åby Jubileumslopp 1941, Svenskt Mästerskap 1941, 1942, Solvalla Grand Prix 1940, C.Th. Ericssons Memorial 1941 och Walter Lundbergs Memorial 1942.</p>
</p></div>
</p></div>
</p></div>
</p></div>
<div class="expand">
						<span class="text">Expandera</span><br />
						<span class="icon sprites"></span>
					</div>
</p></div>
</p></div>



<p class="wp-block-paragraph">Big Noon var som sagt inte bara en stjärna på tävlingsbanan, utan omskriven som få andra hästar utanför travets värld och sålunda även välkänd hos den stora folkmassan. Om Big Noon skrevs det i alla typer av tidningar – från dagspress till veckotidningar.</p>



<p class="wp-block-paragraph">Samma år som Big Noon dog fick han en löpning uppkallad efter sig på Solvalla. Första upplagan av Big Noon-pokalen hölls 1964, några månader efter att han gått bort.</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/11/villekarhulahti-617x333.jpg" alt="" class="wp-image-659822"/><figcaption class="wp-element-caption">Ville Karhulahti tränar BC-finaltrean Currency Artist. Foto Mathias Hedlund/Sulkysport</figcaption></figure>



<p class="has-drop-cap wp-block-paragraph">2 …och i eftermiddag är det dags för årets upplaga av hyllningsloppet till Big Noon som efter att under åtta år avgjorts under Jubileumspokalskvällen på Solvalla hittat tillbaka till hösten där det legat sedan premiäråret 1964.</p>



<p class="wp-block-paragraph">Treåringarna har 20 meter tillgodo på fyraåringarna och statistiken de 20 senaste åren ger födel de yngre hästarna, 12-8 till treåringarna. De tio senaste upplagorna är det dock helt jämnt, 5-5.</p>



<p class="wp-block-paragraph">På startfållan finns färska Breeders Crown-finaltrean <strong>Currency Artist</strong> (e. Royalty For Life).<br>– Han tog senaste loppet så bra och var pigg och glad efter loppet, så då bestämde jag att prova här också. Det är svårt säga om ännu bättre, men är han lika bra räcker det ganska långt. Voltstart tror jag går bra, det är en klok och förnuftig häst och han är snabb i benen också. Han tävlar kanske med bakskor nu, han blir lite snabbare i starten då, men han har gått väldigt bra barfota runt om så jag får klura lite, sade tränaren Ville Karhulahti till V65 Direkt.</p>



<p class="wp-block-paragraph">Daniel Redéns Sprintermästare från i somras, jänkaren <strong>Crown</strong> (e. Chapter Seven), finns på tilläggsfållan.<br>– Han var väldigt bra på Bjerke senast och formen ska inte vara sämre nu. Nu blir det tufft då det var så många på start. Sedan blir det första gången med volt som det krävs något av honom i starten. Vi får se hur det går, men han brukar ju göra bra lopp och brukar veta vad han ska göra. Han kommer gå i Finntack-vagnen så det blir marginell skillnad, säger Daniel Redén på Stall Zets hemsida.</p>



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



<p class="has-drop-cap wp-block-paragraph">325 miljoner kronor extra har lagts in i eftermiddagens sjurättspott på V75 i en omgång med både vanliga STL-propositioner, Big Noon-pokalen och The Owners Trophy över lång distans med hästar på tre volter. Dessutom Konung Carl XVI Gustafs Silverhäst, gulddivisionen med 300.000 kronor till vinnaren.</p>



<p class="wp-block-paragraph"><a href="https://sulkysport.se/spelstugan/v75-tips-tva-spikar-i-jakten-pa-50-millar/" target="_blank" rel="noreferrer noopener">––> Här är Sulkysports tipsgenomgång till V75.</a></p>



<p class="wp-block-paragraph">Solvallas Hästägarförenings lopp, The Owners Trophy, har genom åren sett vinnare som Meadow Road, Union Shark, Clipton, Herr Jägermeister, Beanie M.M, Triton Sund, Tobin Kronos, Volstead – och framför allt Maharajah.<br>I slutet av oktober 2013 segrade han i loppet. Tre månader senare stod han som vinnare i Prix d’Amérique!<br>I dagens lopp startar en son till Maharjah, Daniel Wäjersten-tränade <strong>Chitchat</strong>, som fått ett lopp i kroppen på svensk mark efter en Frankrike-sejour.</p>



<p class="wp-block-paragraph">Ready Cash var hästen som ”lurade” Maharajah på Pd’A-segern 2011 när svensken slutade tvåa, vann även 2012, slutade tvåa 2013 och gjorde bort sig med galopp när Maharajahs stora stund var kommen.<br>En son och en sonson till Ready Cash kan göra upp om segern i årets The Owners Trophy: Daniel Redéns <strong>Imperatur Am</strong> (e. Ready Cash) och <strong>Keep Gamble</strong> (e. Ready Cash-sonen Cash Gamble) från Timo Nurmos stall.</p>



<p class="wp-block-paragraph"><a href="https://sulkysport.se/v75-jackpot-magnus-basta-chans-av-fem-favoriter/" target="_blank" rel="noreferrer noopener">Så här säger Magnus A Djuse om Keep Gamble och sina andra sex V75-hästar.</a></p>



<p class="wp-block-paragraph">Hos vår samarbetspartner Travnet finns andelar till dagens V75-omgång på Högkvarteret:<br><a href="https://www.atg.se/hogkvarteret/V75_2024-11-30_5_5" target="_blank" rel="noreferrer noopener">Här är alla andelar!</a></p>



<p class="wp-block-paragraph">Färjestad (start 18.30) tar vid efter Solvallas V75-tävlingar och Peter Zadel får chansen bakom <strong>Magic Bourbon</strong> (e. Face Time Bourbon), som tränas av chefen Björn Goop. Treåringen har inlett med två segrar och ett andrapris på tre starter.</p>



<p class="wp-block-paragraph"><a href="https://sulkysport.se/wp-content/uploads/2024/11/241130.pdf" target="_blank" rel="noreferrer noopener">Här är startlistorna till lördagens tävlingar på svensk mark.</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/2024/01/prixdecroix1-617x362.jpg" alt="" class="wp-image-542387"/><figcaption class="wp-element-caption">Jushua Tree och Jean-Michel Bazire vann före invändiga Joviality föra vintern. Foto: Gerard Forni</figcaption></figure>



<p class="has-drop-cap wp-block-paragraph">4Comeback på tävlingsbanan efter 147 dagars uppehåll väntar för 26-faldiga miljonärskan <strong>Joviality</strong> (e. Chapter Seven) i eftermiddag – och tränaren Sabine Kagebrant väljer Vincennes som spelplats för återkomsten.</p>



<p class="wp-block-paragraph">Jovialty körs, som i tre av fyra starter förra vintern, av Benjamin Rochard. Tillsammans slutade duon då tvåa i grupp II-loppet Prix de Croix (€120.000) och där fick hon se sig besegrad av <strong>Jushua Tree</strong> (e. Bold Eagle) och Jean Michel Bazire.<br>Bazire-stallets största Prix d’Amérique-hopp finns också bland motståndarna idag när pappa Jean Michel kör hästen som numera tränas av sonen Nicolas.</p>



<p class="wp-block-paragraph">Joviality är enda blågula inslaget på Vincennes idag.</p>



<p class="wp-block-paragraph"><strong>Startlista Prix Doynel de Saint-Quentin (€120.000)</strong><br>Femåriga hingstar &#038; ston, 2.850 meter:<br><em>Namn (far) – Körsven/tränare</em></p>



<ol class="wp-block-list">
<li><strong>Jack Tonic</strong> (e. Charly du Noyer) – Théo Duvaldestin/Thierry Duvaldestin</li>



<li><strong>J’Aime Le Foot</strong> (e. Boccador de Simm) – Eric Raffin/Antoine Lherete</li>



<li><strong>Justin Bold</strong> (e. Bold Eagle) – Pierre-Yves Verva/Jean-Rémi Delliaux</li>



<li><strong>Junionho Dry</strong> (e. Carat Williams) – Paul-Philippe Ploquin/Sébastien Guarato</li>



<li><strong>Jushua Tree</strong> (e. Bold Eagle) – Jean-Michel Bazire/Nicolas Bazire</li>



<li><strong>Joviality</strong> (e. Chapter Seven) – Benjamin Rochard/Sabine Kagebrant</li>
</ol>



<p class="wp-block-paragraph"><a href="https://sulkysport.se/trav-och-galopp/paris-vincennes-2024-11-30/" target="_blank" rel="noreferrer noopener">Här är startlistorna till alla lopp.</a></p>



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



<p class="has-drop-cap wp-block-paragraph">5Efter 16 månader i träning hos Daniel Redén – med sommarens triumf i Stochampionatet som absolut höjdpunkt – flyttade <strong>Kinglet Bird</strong> (e. Nuncio) hem till ägaren Janne Korpi i Finland efter att ha slutat oplacerad i finalen av Breeders Crown i Eskilstuna för två veckor sedan.</p>



<p class="wp-block-paragraph">Redan i eftermiddag är hon tillbaka på tävlingsbanan. Janne Korpi plockar ut henne i en stoelit på huvudstadsbanan Vermo med 7.000 euro i förstapris. Kinglet Bird är ensam fyraåring och ställs mot nio äldre ston, där dubbelmiljonärskan <strong>Halley Wania</strong> (e. E L Titan) är den mest meriterade.</p>



<p class="wp-block-paragraph">Ari Moilanen hoppar upp i sulkyn bakom Kinglet Bird, som vunnit åtta av 21 starter och sprungit in 3.664.930 kronor hittills.</p>



<p class="wp-block-paragraph"><a href="https://heppa.hippos.fi/heppa/app?ct=YXBwbGljYXRpb24vcGRm&#038;d=dHJ1ZQ%3D%3D&#038;dr=&#038;f=b2hqZWxtYXRpZWRvdC5IXzMwLjExLjIwMjQucGRm&#038;m=FK4vOhsvdKV4EF9ZJGmnaq0nRts%3D&#038;service=pdftmp" target="_blank" rel="noreferrer noopener">Här är startlistorna till Vermos tävlingar idag.</a></p>



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



<p class="has-drop-cap wp-block-paragraph">6Tio segrar på 20 starter, men bara en start de senaste två säsongerna. Ikväll på Traveras internetauktion bjuds meriterade sjuåringen <strong>Napoleon Cash</strong> (e. Djali Boko) ut till försäljning.</p>



<p class="wp-block-paragraph">Napoleon Cash är en av 17 starthäsar på auktionen som totalt innehåller 33 nummer. Tio av dem är fölston, bland annat en Muscle Hill-dotter dräktig med Ecurie D. där levande föl-avgiften ingår.</p>



<p class="wp-block-paragraph">Tre ettåringar (med papporna Charly du Noyer, Classic Photo och In Range), en tvååring efter Mister J.P, en livstids betäckningsrätt i Önas Prince och en årsbetäckning med Trixton 2025 finns också i utbudet.</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">7 Hela 1.377.000 dollar tävlas det om på Meadowlands i natt svensk tid och 15 svensktränade hästar selas ut i Goldsmith Maid ($455.000), Valley Victory ($447.000) och i öppna respektive stonas uppgörelse i Fanduel Championship ($325.000/$150.000).</p>



<figure class="wp-block-image size-sulky-mellan2"><img src="https://sulkysport.se/wp-content/uploads/2024/10/superchapterddm241004adamstromstalltz-617x388.jpg" alt="" class="wp-image-642865"/><figcaption class="wp-element-caption">Super Chapter och Dexter Dunn. Foto: Adam Ström/stalltz.se</figcaption></figure>



<p class="wp-block-paragraph"><strong>Valley Victory </strong>($447.000)<br>Tvååriga hingstar/valacker.<br><em>1.609 meter, autostart.</em></p>



<p class="wp-block-paragraph"><strong>Namn (far) – Körsven/tränare</strong></p>



<ol class="wp-block-list">
<li><strong>My Degenerate</strong> (e. Muscle Hill) – Andy Miller/Julie Miller</li>



<li><strong>Uno</strong> (e. Tactical Landing) – Anbal Borjas/Tony Alagna</li>



<li><strong>Herecomesdajudge</strong> (e. Muscle Hill) – Tyler Miller/Julie Miller</li>



<li><strong>Blank</strong> (e. Gimpanzee) – Andrew McCarthy/Marcus Melander</li>



<li><strong>Monserrate</strong> (e. Chapter Seven) – David Miller/Andrew Harris</li>



<li><strong>Go Dog Go</strong> (e. Greenshoe) – Todd McCarthy/Carter Pinske</li>



<li><strong>Durante Hanover</strong> (e. Walner) – Yannick GingrasJim Oscarsson</li>



<li><strong>Super Chapter </strong>(e. Chapter Seven) – Dexter Dunn/Marcus Melander</li>



<li><strong>Yannick G Kemp</strong> (e. Walner) – Scott Zeron/Nifty Norman</li>
</ol>



<p class="wp-block-paragraph"><strong>Goldsmith Maid </strong>($455.000)<br>Tvååriga ston.<br><em>1.609 meter, autostart.</em></p>



<p class="wp-block-paragraph"><strong>Namn (far) – Körsven/tränare</strong></p>



<ol class="wp-block-list">
<li><strong>R Dutchess</strong> (e. Father Patrick) – Corey Callahan/John Butenschoen</li>



<li><strong>Panacea Hanover</strong> (e. Walner) – Rikard N Skoglund/Lucas Wallin</li>



<li><strong>Luna Lovegood </strong>(e. Gimpanzee) – Dexter Dunn/Marcus Melander</li>



<li><strong>Voguish </strong>(e. Gimpanzee) – Todd McCarthy/Andrew Harris</li>



<li><strong>Spicy Nice</strong> (e. Tactical Landing) – Yannick Gingras/Nancy Takter</li>



<li><strong>Miss Belmar</strong> (e. Muscle Hill) – Andrew McCarthy/Noel Daley</li>



<li><strong>Sound Judgement</strong> (e. Muscle Hill) – David Miller/Jim Oscarsson</li>



<li><strong>What A Bid Hanover</strong> (e. Muscle Hill) – Åke Svanstedt</li>



<li><strong>R Charm </strong>(e. Propulsion) – Scott Zeron/Linda Toscano</li>



<li><strong>Champagne Problems </strong>(e. Tactical Landing) – James MacDonald/Nancy Takter</li>
</ol>



<p class="wp-block-paragraph"><strong>Fanduel Championship</strong> ($325.000)<br>Äldre travare.<br><em>1.609 meter, autostart.</em></p>



<p class="wp-block-paragraph"><strong>Namn (far) – Körsven/tränare</strong></p>



<ol class="wp-block-list">
<li><strong>Logan Park</strong> (e. Archangel) – Doug McNair/Robert Fellows</li>



<li><strong>Oh Well </strong>(e. Muscle Hill) – Todd McCaarthy/Marcus Melander</li>



<li><strong>Asteroid </strong>(e. Creatine) – Tim Tetrick/Jeff Cullipher</li>



<li><strong>Periculum</strong> (e. Muscle Hill) – Scott Zeron/Marcus Melander</li>



<li><strong>Hillexotic</strong> (e. Muscle Hill) – Austin Hanners/Todd Luther</li>



<li><strong>Winner’s Bet</strong> (e. Walner) – Dexter Dunn/Nancy Takter</li>



<li><strong>Up Your Deo</strong> (e. Walner) – Åke Svanstedt</li>



<li><strong>It’s Academic</strong> (e. Uncle Peter) – David Miller/Ron Burke</li>
</ol>



<p class="wp-block-paragraph"><strong>Fanduel Championship</strong> ($150.000)<br>Äldre ston.<br><em>1.609 meter, autostart.</em></p>



<p class="wp-block-paragraph"><strong>Namn (far) – Körsven/tränare</strong></p>



<ol class="wp-block-list">
<li><strong>Warrawee Xenia</strong> (e. Walner) – Jason Bartlett/Mark Steacy</li>



<li><strong>Allegiant</strong> (e. Tactical Landing) – Scott Zeron/Linda Toscano</li>



<li><strong>M-M’s Dream</strong> (e. Swan For All) – David Miller/Ron Burke</li>



<li><strong>R Melina </strong>(e. Chapter Seven) – Todd McCarthy/John Butenschoen</li>



<li><strong>Call Me Goo</strong> (e. Googoo Gaagaa) – Åke Svanstedt</li>



<li><strong>Nelson Brite Eagle</strong> (e. Bold Eagle) – Dexter Dunn/Åke Svanstedt</li>
</ol>

Fokustema
Sju nyheter vid sju
Läs senare
”Är han lika bra räcker det ganska långt”
Big Noon fick svensken att ryta under Andra världskriget. 5-5 mellan tre- och fyraåringar. Jackpot med 50 miljoner i V75-potten. Joviality mot Bazires Pd'A-hopp. Stochampionatsvinnare debuterar i nygammal regi. Svensk miljonjakt i USA.
Detta och mer i lördagens nyhetssvep.
Detta och mer i lördagens nyhetssvep.
