Aún no hay reacciones. ¡Sé el primero! <p style="text-align: center;"><img src="https://l10preunestawamb.blob.core.windows.net/lpa/images/legacy/201506/662x372a_04175121article0.jpg" alt="" /></p>
<p align="center">&nbsp;</p>
<p align="center"><strong>Inauguraci&oacute;n de la temporada 1969/70 ante el Elche.</strong></p>
<p align="center">&nbsp;</p>
<p><strong>Ambos equipos hab&iacute;an obtenido en el a&ntilde;o anterior el subcampeonato del torneo liguero y la Copa del General&iacute;simo.</strong></p>
<p>Se iniciaba la pretemporada 1969/70 con el Trofeo Colombino de Huelva, el viaje a la isla de Madeira para enfrentarse al Nacional y superar al Tenerife Atl&eacute;tico en el Trofeo Inca.</p>
<p><img src="https://l10preunestawamb.blob.core.windows.net/lpa/images/legacy/201506/662x372a_051332151.jpg" alt="" /></p>
<p><em>Equipo del Nacional de Funchal.</em></p>
<p>&nbsp;</p>
<p><img src="https://l10preunestawamb.blob.core.windows.net/lpa/images/legacy/201506/662x372a_051332432.jpg" alt="" /></p>
<p><em>Formaci&oacute;n que present&oacute; la UD Las Palmas ante el Tenerife Atl&eacute;tico en el Trofeo Inca.</em></p>
<p><em>De izquierda a derecha, de pi&eacute;: Catal&aacute;, Mart&iacute;n II, Tonono, Hern&aacute;ndez, Menchu y Trona.</em></p>
<p><em>De rodillas: Le&oacute;n, Gilberto II, Jos&eacute; Juan, Germ&aacute;n y Gilberto I.</em></p>
<p>&nbsp;</p>
<p><img src="https://l10preunestawamb.blob.core.windows.net/lpa/images/legacy/201506/662x372a_051333173.jpg" alt="" /></p>
<p><em>Componentes del Tenerife Atl&eacute;tico posando para la c&aacute;mara de Hern&aacute;ndez Gil en los proleg&oacute;menos del encuentro.</em></p>
<p>&nbsp;</p>
<p><img src="https://l10preunestawamb.blob.core.windows.net/lpa/images/legacy/201506/662x372a_051333374.jpg" alt="" /></p>
<p><em>Los capitanes de la UD Las Palmas y Tenerife Atl&eacute;tico, Tonono y Alberto Molina, en presencia del tr&iacute;o arbitral.</em></p>
<p><img src="https://l10preunestawamb.blob.core.windows.net/lpa/images/legacy/201506/662x372a_051334125.jpg" alt="" /></p>
<p><em>Primer gol del partido de potente disparo de Germ&aacute;n.</em></p>
<p>&nbsp;</p>
<p><img src="https://l10preunestawamb.blob.core.windows.net/lpa/images/legacy/201506/662x372a_051334476.jpg" alt="" /></p>
<p><em>El capit&aacute;n amarillo Tonono levantando el Trofeo Inca a los aficionados en el Estadio Insular.</em></p>
<p>&nbsp;</p>
<p>En el Bodeg&oacute;n del Pueblo Canario se distingu&iacute;a al extremo amarillo Le&oacute;n con la Copa Quillet por ser el m&aacute;ximo goleador de la campa&ntilde;a anterior. En el mismo acto el defensa Tonono recibir&iacute;a un coche de la marca Ford y el bal&oacute;n de oro de la casa Ron Guajiro etiqueta negra como el jugador m&aacute;s regular.</p>
<p><img src="https://l10preunestawamb.blob.core.windows.net/lpa/images/legacy/201506/662x372a_051335247-a.jpg" alt="" /></p>
<p><em>El extremo amarillo Jos&eacute; manuel Le&oacute;n recibe el trofeo de m&aacute;ximo goleador.</em></p>
<p><img src="https://l10preunestawamb.blob.core.windows.net/lpa/images/legacy/201506/662x372a_051335587-b.jpg" alt="" /></p>
<p><em>La esposa de Jos&eacute; Manuel Le&oacute;n, Mayole Torrent, observa con entusiasmo el trofeo de m&aacute;ximo goleador en presencia de su marido.</em></p>
<p><img src="https://l10preunestawamb.blob.core.windows.net/lpa/images/legacy/201506/662x372a_051336398.jpg" alt="" /></p>
<p><em>En la instant&aacute;nea, el Trofeo Quillet, ganado por el jugador Jos&eacute; Manuel Le&oacute;n al proclamarse m&aacute;ximo goleador de la temporada 1968/69. Al lado el magno trofeo al jugador que se proclamara mayor realizador del equipo durante tres temporadas consecutivas, trofeo obtenido con posterioridad por el diez amarillo Germ&aacute;n D&eacute;vora.</em></p>
<p><img src="https://l10preunestawamb.blob.core.windows.net/lpa/images/legacy/201506/662x372a_051337059.jpg" alt="" /></p>
<p><em>En la instant&aacute;nea el defensa Tonono mostrando el bal&oacute;n de oro como el jugador m&aacute;s regular.</em></p>
<p>&nbsp;</p>
<p>En el cap&iacute;tulo de contrariedades la baja del pundonoroso delantero Jos&eacute; Juan que hab&iacute;a sufrido un tir&oacute;n muscular ante su antiguo equipo. En el caso del jugador tinerfe&ntilde;o, su inesperada lesi&oacute;n no s&oacute;lo truncaba sus esperanzas de comenzar la liga en la formaci&oacute;n titular ante el Elche sino la ilusi&oacute;n de participar en la primera competici&oacute;n jugada por un club isle&ntilde;o a nivel europeo como era la Copa de Ferias ante el Hertha de Berl&iacute;n.</p>
<p><img src="https://l10preunestawamb.blob.core.windows.net/lpa/images/legacy/201506/662x372a_0513375110.jpg" alt="" /></p>
<p><em>Jos&eacute; Juan.</em></p>
<p>Sin embargo, todo no iban a ser malas noticias: el espigado medio isle&ntilde;o Juanito Guedes era indultado por la Real Federaci&oacute;n Espa&ntilde;ola de F&uacute;tbol tras su sanci&oacute;n.</p>
<p><img src="https://l10preunestawamb.blob.core.windows.net/lpa/images/legacy/201506/662x372a_0513385311.jpg" alt="" /></p>
<p><em>Juanito Guedes.</em></p>
<p>El entrenador Luis Molowny hab&iacute;a comentado a diferentes medios informativos a pi&eacute; de campo la probabilidad de concentrar quince jugadores, de los que s&oacute;lo podr&iacute;an participar trece.</p>
<p><img src="https://l10preunestawamb.blob.core.windows.net/lpa/images/legacy/201506/662x372a_0513392212.jpg" alt="" /></p>
<p><em>Luis Molowny en un entrenamiento vespertino en el Estadio Insular. Al fondo, el Secretario General de la entidad, D. Jes&uacute;s Garc&iacute;a Panasco.</em></p>
<p>En cuanto a nuestro primer rival, no era otro que el correoso equipo ilicitano del Elche, dirigido por Roque M&aacute;spoli, con varios internacionales en sus filas entre los que destacaban Ballester y Asensi, convocados a la Sub-23 por Ladislao Kubala.</p>
<p><img src="https://l10preunestawamb.blob.core.windows.net/lpa/images/legacy/201506/662x372a_0513400213.jpg" alt="" /></p>
<p><em>Saluda del presidente del Elche CF, D. Jos&eacute; Esquitino Sempere, a la UD Las Palmas agradeciendo su felicitaci&oacute;n por obtener el subcampeonato de la Copa del General&iacute;simo.</em></p>
<p>Paralelamente, el conjunto alem&aacute;n del Hertha de Berl&iacute;n era esperado con la mayor expectaci&oacute;n, hosped&aacute;ndose en el Hotel Reina Isabel de nuestra ciudad.</p>
<p>La UD Las Palmas tendr&iacute;a por consiguiente tres encuentros en una semana. El debut en competici&oacute;n liguera ante el Elche, que como todos los encuentros de aquellas d&eacute;cadas tras la instalaci&oacute;n artificial, eran jugados los s&aacute;bados por la noche; al siguiente mi&eacute;rcoles nuestra participaci&oacute;n en la Copa de Ferias por primera vez en la historia y por &uacute;ltimo ante el conjunto colchonero del Atl&eacute;tico de Madrid en el estadio del Manzanares.</p>
<p><img src="https://l10preunestawamb.blob.core.windows.net/lpa/images/legacy/201506/662x372a_0513403014.jpg" alt="" /></p>
<p><em>Panor&aacute;mica del Estadio Insular en un encuentro nocturno a finales de los sesenta.</em></p>
<p>El entrenador canario Luis Molowny, previniendo la sensible baja de Jos&eacute; Juan, hab&iacute;a ubicado en su demarcaci&oacute;n al ex artesanista Trona, jugador de otras caracter&iacute;sticas que el tinerfe&ntilde;o pero siempre peligroso de cara al gol por su gran altura y corpulencia.</p>
<p><img src="https://l10preunestawamb.blob.core.windows.net/lpa/images/legacy/201506/662x372a_0513410015.jpg" alt="" /></p>
<p><em>Trona.</em></p>
<p>El equipo volv&iacute;a a concentrarse en el Hotel Santa Br&iacute;gida, lugar de hospedaje por antonomasia de la UD Las Palmas, pernoctando all&iacute; desde el viernes con la finalidad de recibir al Elche, hasta el jueves de la semana siguiente, dado su compromiso europeo con el Hertha de Berl&iacute;n.</p>
<p><img src="https://l10preunestawamb.blob.core.windows.net/lpa/images/legacy/201506/662x372a_0513412616.jpg" alt="" /></p>
<p><em>Instant&aacute;nea del Hotel Santa Br&iacute;gida.</em></p>
<p><img src="https://l10preunestawamb.blob.core.windows.net/lpa/images/legacy/201506/662x372a_0513415617.jpg" alt="" /></p>
<p><em>Paraje del Monte Lentiscal donde sol&iacute;an pasear con frecuencia nuestros jugadores acompa&ntilde;ados del t&eacute;cnico Luis Molowny.</em></p>
<p>&nbsp;</p>
<p><strong>Juan Guedes lucir&iacute;a el brazalete de capit&aacute;n.</strong></p>
<p>El espigado jugador amarillo se incorporaba al club en la temporada 1960/61 procedente del Porte&ntilde;o. Fue Casimiro Benavente quien le dar&iacute;a la gran oportunidad en el Alfonso Murube de Ceuta.</p>
<p><img src="https://l10preunestawamb.blob.core.windows.net/lpa/images/legacy/201506/662x372a_0513422618.jpg" alt="" /></p>
<p><em>Formaci&oacute;n del Porte&ntilde;o con Juanito Guedes en sus filas poco antes de su incorporaci&oacute;n a la UD Las Palmas.</em></p>
<p><img src="https://l10preunestawamb.blob.core.windows.net/lpa/images/legacy/201506/662x372a_0513425019.jpg" alt="" /></p>
<p><em>Juanito Guedes en los primeros a&ntilde;os de la d&eacute;cada de los sesenta.</em></p>
<p><img src="https://l10preunestawamb.blob.core.windows.net/lpa/images/legacy/201506/662x372a_0513431720.jpg" alt="" /></p>
<p><em>Casimiro Benavente.</em></p>
<p><img src="https://l10preunestawamb.blob.core.windows.net/lpa/images/legacy/201506/662x372a_0513434521.jpg" alt="" /></p>
<p><em>Estadio del Alfonso Murube de Ceuta el d&iacute;a del debut de Juanito Guedes. En la instant&aacute;nea, el capit&aacute;n Aparicio y el masajista Pepe Gonz&aacute;lez auxilian al guardameta Antonio Betancor que ser&iacute;a sustituido por Ulacia.</em></p>
<p>Hasta la temporada anterior 1968/69 era el bravo defensa Aparicio quien realizaba esa funci&oacute;n. Sin embargo, al ser sustituido en la alineaci&oacute;n por el tinerfe&ntilde;o Mart&iacute;n II dejaba su cargo a su inseparable amigo Juanito Guedes quien llevar&iacute;a el brazalete de capit&aacute;n ante el conjunto ilicitano.</p>
<p><img src="https://l10preunestawamb.blob.core.windows.net/lpa/images/legacy/201506/662x372a_0513442122.jpg" alt="" /></p>
<p><em>Aparicio.</em></p>
<p>Otra buena noticia para el once amarillo era el debut del tambi&eacute;n ex artesanista Guillermo Hern&aacute;ndez, lateral izquierdo que hab&iacute;a causado una inmejorable impresi&oacute;n en la Liga Interregional con el Aficionado.</p>
<p><img src="https://l10preunestawamb.blob.core.windows.net/lpa/images/legacy/201506/662x372a_0513444923.jpg" alt="" /></p>
<p><em>El debutante Guillermo Hern&aacute;ndez posando en el Estadio Insular con la indumentaria de entrenamiento y las populares botas "El Gallo".</em></p>
<p>La UD Las Palmas concentraba en este primer partido de liga a los siguientes jugadores:</p>
<p>Oregui, Catal&aacute;, Mart&iacute;n II, Tonono, Hern&aacute;ndez, Jos&eacute; Luis, Castellano, Guedes, Menchu, Le&oacute;n, Lemes, Gilberto II, Trona, Germ&aacute;n y Gilberto I.</p>
<p>El t&eacute;cnico Luis Molowny distribu&iacute;a las habitaciones de la siguiente forma:</p>
<p>Oregui-Catal&aacute;</p>
<p>Jos&eacute; Luis-Lemes</p>
<p>Tonono-Guedes</p>
<p>Mart&iacute;n II-Le&oacute;n</p>
<p>Castellano-Germ&aacute;n</p>
<p>Gilberto I-Gilberto II</p>
<p>Hern&aacute;ndez-Trona</p>
<p>Menchu-Jos&eacute; Gonz&aacute;lez (masajista)</p>
<p>&nbsp;</p>
<p>El Secretario General del club, Jes&uacute;s Garc&iacute;a Panasco, y Luis Molowny ocupaban habitaciones individuales.</p>
<p>Aunque todo depend&iacute;a del entrenador del momento, algunos de los jugadores, ya fuera por antig&uuml;edad, afinidad o grado de amistad, sol&iacute;an tener sus preferencias que por regla general contaban con la aceptaci&oacute;n del t&eacute;cnico.</p>
<p>Por norma todos los porteros con que ha contado el club desde la &eacute;poca fundacional han ido siempre juntos. En este caso, ante la ausencia de Ulacia, el reci&eacute;n incorporado guardameta, Catal&aacute;, compartir&iacute;a la habitaci&oacute;n con Oregui. El lateral zurdo Jos&eacute; Luis, muchacho extrovertido y bromista, ausente de la alineaci&oacute;n titular, no le importaba emparejarse con el novato Paco Lemes en su primera concentraci&oacute;n.</p>
<p>&nbsp;<img src="https://l10preunestawamb.blob.core.windows.net/lpa/images/legacy/201506/662x372a_0513464724.jpg" alt="" /> <img src="https://l10preunestawamb.blob.core.windows.net/lpa/images/legacy/201506/662x372a_0513464825.jpg" alt="" /></p>
<p><em>Oregui y Catal&aacute;.</em></p>
<p>&nbsp; <br /><img src="https://l10preunestawamb.blob.core.windows.net/lpa/images/legacy/201506/662x372a_0513483426.jpg" alt="" />&nbsp;&nbsp;<img src="https://l10preunestawamb.blob.core.windows.net/lpa/images/legacy/201506/662x372a_0513483427.jpg" alt="" /></p>
<p><em>Jos&eacute; Luis y Paco Lemes.</em></p>
<p>Ser&iacute;a innecesario significar que Guedes y Tonono, los m&aacute;s veteranos del grupo, eran inseparables tanto dentro como fuera de la cancha.</p>
<p>&nbsp; <br /><img src="https://l10preunestawamb.blob.core.windows.net/lpa/images/legacy/201506/662x372a_0513495728.jpg" alt="" width="662" height="667" /> <img src="https://l10preunestawamb.blob.core.windows.net/lpa/images/legacy/201506/662x372a_0513495829.jpg" alt="" /></p>
<p><em>Guedes y Tonono.</em></p>
<p>Con Mart&iacute;n II y Le&oacute;n o Castellano y Germ&aacute;n suced&iacute;a algo parecido aunque con mayor flexibilidad.</p>
<p>&nbsp;<img src="https://l10preunestawamb.blob.core.windows.net/lpa/images/legacy/201506/662x372a_0513512530.jpg" alt="" /> <img src="https://l10preunestawamb.blob.core.windows.net/lpa/images/legacy/201506/662x372a_0513512631.jpg" alt="" /></p>
<p><em>Mart&iacute;n II y Le&oacute;n.</em></p>
<p><em><img src="https://l10preunestawamb.blob.core.windows.net/lpa/images/legacy/201506/662x372a_0513521132.jpg" alt="" /> <img src="https://l10preunestawamb.blob.core.windows.net/lpa/images/legacy/201506/662x372a_0513521233.jpg" alt="" /><br /></em></p>
<p><em>Castellano y Germ&aacute;n.</em></p>
<p>Los tinerfe&ntilde;os Gilberto I y Gilberto II ten&iacute;an tambi&eacute;n gran afinidad aunque el interior sol&iacute;a compartir habitaci&oacute;n con el delantero Jos&eacute; Juan, lesionado en este inicio de competici&oacute;n.</p>
<p><em><img src="https://l10preunestawamb.blob.core.windows.net/lpa/images/legacy/201506/662x372a_0513530235.jpg" alt="" /> <img src="https://l10preunestawamb.blob.core.windows.net/lpa/images/legacy/201506/662x372a_0513530334.jpg" alt="" /><br /></em></p>
<p><em>Gilberto I y Gilberto II.</em></p>
<p>Era igualmente natural que dos&nbsp; jugadores formados en la cantera del Artesano como Hern&aacute;ndez y Trona tuvieran sentimientos paralelos y muchas cosas de que hablar.</p>
<p><img src="https://l10preunestawamb.blob.core.windows.net/lpa/images/legacy/201506/662x372a_0513535736.jpg" alt="" /> <img src="https://l10preunestawamb.blob.core.windows.net/lpa/images/legacy/201506/662x372a_0513535737.jpg" alt="" /></p>
<p><em>Hern&aacute;ndez y Trona.</em></p>
<p>Por &uacute;ltimo, el joven Menchu, que hab&iacute;a realizado grandes campa&ntilde;as en el Aficionado y San Antonio, agradec&iacute;a la compa&ntilde;&iacute;a del veterano masajista Jos&eacute; Gonz&aacute;lez.</p>
<p><img src="https://l10preunestawamb.blob.core.windows.net/lpa/images/legacy/201506/662x372a_0513544239.jpg" alt="" /> <img src="https://l10preunestawamb.blob.core.windows.net/lpa/images/legacy/201506/662x372a_0513544238.jpg" alt="" /></p>
<p><em>Menchu y Pepe Gonz&aacute;lez.</em></p>
<p><em><img src="https://l10preunestawamb.blob.core.windows.net/lpa/images/legacy/201506/662x372a_0513553440.jpg" alt="" /> <img src="https://l10preunestawamb.blob.core.windows.net/lpa/images/legacy/201506/662x372a_0513553541.jpg" alt="" /><br /></em></p>
<p><em>El Secretario General del club, D. Jes&uacute;s Garc&iacute;a Panasco y el t&eacute;cnico Luis Molowny ocupaban habitaciones individuales.</em></p>
<p>&nbsp;</p>
<p align="center"><img src="https://l10preunestawamb.blob.core.windows.net/lpa/images/legacy/201506/662x372a_0513562842.jpg" alt="" />&nbsp;</p>
<p style="text-align: center;">&nbsp;</p>
<p style="text-align: center;">&nbsp;</p>
<p><strong>En el partido de apertura de la liga la UD Las Palmas golea al Elche por cinco tantos a uno.</strong></p>
<p><strong>En el encuentro inaugural del campeonato, el equipo amarillo doblegaba al conjunto ilicitano infringi&eacute;ndole una abultada goleada.</strong></p>
<p>Se enfrentaban nada m&aacute;s y nada menos que el subcampe&oacute;n de liga &ndash;UD Las Palmas- y el subcampe&oacute;n de Copa del General&iacute;simo &ndash;Elche CF- con una inmejorable entrada de p&uacute;blico.</p>
<p><img src="https://l10preunestawamb.blob.core.windows.net/lpa/images/legacy/201506/662x372a_0513595243.jpg" alt="" /></p>
<p><em>Alineaci&oacute;n que presentar&iacute;a la UD las Palmas ante el Elche CF.</em></p>
<p><em>De izquierda a derecha, de pi&eacute;: Oregui, Mart&iacute;n II, Tonono, Hern&aacute;ndez, Castellano y Guedes.</em></p>
<p><em>De rodillas: Le&oacute;n, Gilberto II, Trona, Germ&aacute;n y Gilberto I.</em></p>
<p>&nbsp;</p>
<p><img src="https://l10preunestawamb.blob.core.windows.net/lpa/images/legacy/201506/662x372a_0514001744.jpg" alt="" /></p>
<p><em>Formaci&oacute;n del Elche CF ante la UD Las Palmas. </em></p>
<p><em>De izquierda a derecha, de pi&eacute;: Araquistain, Ballester,&nbsp; Iborra, Can&oacute;s, Silvio y Gonz&aacute;lez.</em></p>
<p><em>De rodillas: Serena, Curro,&nbsp; Lezcano, Asensi y Emilio.</em></p>
<p>&nbsp;</p>
<p><img src="https://l10preunestawamb.blob.core.windows.net/lpa/images/legacy/201506/662x372a_0514005045.jpg" alt="" /></p>
<p><em>Banquillo de la UD Las Palmas.</em></p>
<p><em>De izquierda a derecha: Catal&aacute;, Menchu, Lemes, Pepe Gonz&aacute;lez, Dr. Emilio Tom&eacute;, Luis Molowny y Jos&eacute; Luis.</em></p>
<p>&nbsp;</p>
<p><img src="https://l10preunestawamb.blob.core.windows.net/lpa/images/legacy/201506/662x372a_0514014146.jpg" alt="" /></p>
<p><em>Banquillo del Elche CF comandado por el entrenador Roque M&aacute;spoli.</em></p>
<p>&nbsp;</p>
<p>Aunque se esperaba vencer al Elche, equipo siempre dif&iacute;cil y correoso, nadie pod&iacute;a pensar en una victoria tan contundente y rotunda.</p>
<p>El once canario jug&oacute; un encuentro completo superando al Elche en todos los aspectos.</p>
<p>Si bien es verdad que nuestro equipo luci&oacute; a lo largo de todo el encuentro, no es menos cierto que la primera mitad fue para enmarcar, pr&oacute;diga en excelentes jugadas que deleitaron a los aficionados.</p>
<p>El centro del campo amarillo rendir&iacute;a a la perfecci&oacute;n, elaborando jugadas que surt&iacute;an a los espadas del equipo Le&oacute;n y Gilberto I que penetraban con mucho peligro por sus respectivas bandas. Ambos fueron una pesadilla para los laterales Ballester y Can&oacute;s que se ve&iacute;an impotentes de frenar sus veloces acometidas.</p>
<p>El capit&aacute;n, Juanito Guedes, ser&iacute;a de nuevo el catalizador del gran juego amarillo, recogiendo desde atr&aacute;s el bal&oacute;n para introducirse en la zona de creaci&oacute;n y lanzar centros milim&eacute;tricos a los extremos o entregar a Germ&aacute;n, quien nos deleitar&iacute;a con un f&uacute;tbol de gran calidad.</p>
<p><img src="https://l10preunestawamb.blob.core.windows.net/lpa/images/legacy/201506/662x372a_0514022947.jpg" alt="" /></p>
<p><em>Los capitanes de la UD las Palmas y Elche CF, Juanito Guedes e Iborra se saludan antes del comienzo del encuentro.</em></p>
<p><img src="https://l10preunestawamb.blob.core.windows.net/lpa/images/legacy/201506/662x372a_0514030548.jpg" alt="" /></p>
<p><em>El &aacute;rbitro del colegio asturiano Sr. Medina Iglesias.</em></p>
<p>La victoria del conjunto amarillo se fragu&oacute; desde los comienzos del partido al recibir Gilberto I un pase en profundidad de Juanito Guedes. El extremo amarillo se fue en velocidad de Ballester batiendo al meta Araquistain que iniciaba su salida.</p>
<p><img src="https://l10preunestawamb.blob.core.windows.net/lpa/images/legacy/201506/662x372a_0514032749.jpg" alt="" /></p>
<p><em>El extremo Gilberto I hace subir el primer tanto al casillero amarillo.</em></p>
<p>El segundo tanto canario registrar&iacute;a algo de pol&eacute;mica, protestando los jugadores ilicitanos airadamente el posible fuera de juego de Gilberto II. &Eacute;ste llegaba a la conclusi&oacute;n del primer periodo. Reanudado el juego, a los 68 minutos llegar&iacute;a el tercer gol, obra de Trona, al rematar un tiro de Gilberto I que se le hab&iacute;a escapado de las manos al meta visitante.</p>
<p><img src="https://l10preunestawamb.blob.core.windows.net/lpa/images/legacy/201506/662x372a_0514035850.jpg" alt="" /></p>
<p><em>El incansable jugador tinerfe&ntilde;o Gilberto II, obtiene el segundo gol de la UD Las Palmas ante las protestas del once ilicitano que consideraban que la jugada se hab&iacute;a originado en fuera de juego.</em></p>
<p><img src="https://l10preunestawamb.blob.core.windows.net/lpa/images/legacy/201506/662x372a_0514050851.jpg" alt="" /></p>
<p><em>El joven canterano Trona bate al veterano guardameta Araquistain, estableciendo el tercer tanto de la noche.</em></p>
<p>&nbsp;</p>
<p>Diez minutos hab&iacute;an transcurrido de este tercer gol cuando Germ&aacute;n, en jugada individual, establec&iacute;a el cuarto de la noche. El quinto y &uacute;ltimo se inicia con la cl&aacute;sica incursi&oacute;n del lateral Mart&iacute;n II por la banda derecha, centrando el bal&oacute;n a media altura para que Gilberto I, que ven&iacute;a en carrera, introdujera el bal&oacute;n en la red.</p>
<p><img src="https://l10preunestawamb.blob.core.windows.net/lpa/images/legacy/201506/662x372a_0514055052.jpg" alt="" /></p>
<p><em>De fuerte disparo, Germ&aacute;n hace subir el cuarto gol al marcador.</em></p>
<p><img src="https://l10preunestawamb.blob.core.windows.net/lpa/images/legacy/201506/662x372a_0514061353.jpg" alt="" /></p>
<p><em>El quinto y &uacute;ltimo gol, obra de Gilberto I a centro del lateral Mart&iacute;n II.</em></p>
<p>Concluido el tiempo reglamentario, en los segundos de prolongaci&oacute;n, Asensi obtendr&iacute;a el gol de la honrilla para su equipo, cabeceando el bal&oacute;n con gran maestr&iacute;a.</p>
<p><img src="https://l10preunestawamb.blob.core.windows.net/lpa/images/legacy/201506/662x372a_0514063954.jpg" alt="" /></p>
<p><em>Asensi.</em></p>
<p>Una vez concluido el encuentro, el entrenador ilicitano M&aacute;spoli entrar&iacute;a al terreno de juego con objeto de felicitar a nuestros jugadores, gesto que apreci&oacute; el respetable premi&aacute;ndole con una gran ovaci&oacute;n.</p>
<p><img src="https://l10preunestawamb.blob.core.windows.net/lpa/images/legacy/201506/662x372a_0514070455.jpg" alt="" /></p>
<p><em>Roque M&aacute;spoli.</em></p>
<p><img src="https://l10preunestawamb.blob.core.windows.net/lpa/images/legacy/201506/662x372a_0514072956.jpg" alt="" /></p>
<p><em>Luis Molowny.</em></p>
<p>Los equipos presentar&iacute;an las siguientes formaciones:</p>
<p>UD Las Palmas: Oregui; Mart&iacute;n II, Tonono, Hern&aacute;ndez; Castellano, Guedes; Le&oacute;n, Gilberto II, Trona, Germ&aacute;n y Gilberto I.</p>
<p>Elche CF: Araquistain; Ballester, Iborra, Can&oacute;s; Silvio, Gonz&aacute;lez; Serena, Curro, Lezcano, Asensi y Emilio.</p>
<p>&nbsp;</p>
<p><strong>Esp&iacute;as del Hertha de Berl&iacute;n en el Estadio Insular.</strong></p>
<p>El gerente del Hertha de Berl&iacute;n, Sr. Yakubke, asistir&iacute;a al encuentro acompa&ntilde;ado de su paisano Sr. Robert. Ambos tuvieron palabras de elogio hacia el conjunto canario, destacando la l&iacute;nea media amarilla compuesta por Castellano y Guedes.</p>
<p><img src="https://l10preunestawamb.blob.core.windows.net/lpa/images/legacy/201506/662x372a_0514082157.jpg" alt="" /></p>
<p><em>El gerente del Hertha de Berl&iacute;n, Sr. Yakubke y su acompa&ntilde;ante Sr. Robert siguiendo atentamente las incidencias del partido.</em></p>
<p>&nbsp;</p>
<p><strong>Dedicado a todos aquellos lectores que desean ahondar en la hermosa historia e intrahistoria de la entidad.</strong></p>
<p><strong>La llegada del Hertha BSC Berl&iacute;n.</strong></p>
<p><strong>La correspondencia de la Copa de Ciudades en Feria entre la UD Las Palmas y el Hertha de Berl&iacute;n sale por primera vez a la luz.</strong></p>
<p><img src="https://l10preunestawamb.blob.core.windows.net/lpa/images/legacy/201506/662x372a_0514091558.jpg" alt="" /></p>
<p><em>Carta de D. Juan Gich Bech de Careda, Gerente del CF Barcelona y miembro del Comit&eacute; de la Copa de Ferias al Secretario General de la UD Las Palmas, D. Jes&uacute;s Garc&iacute;a Panasco, comunic&aacute;ndole acuerdos de la &uacute;ltima reuni&oacute;n de la UEFA, celebrada en Lisboa, donde se aprob&oacute; el informe presentado por el presidente de la Copa de Ferias y de la FIFA, Sir Stanley Rous, en la cual al final de las temporadas 1969/70, 1970/71, la Copa de Ferias ser&iacute;a integrada dentro de la UEFA. </em></p>
<p><img src="https://l10preunestawamb.blob.core.windows.net/lpa/images/legacy/201506/662x372a_0514094959.jpg" alt="" /></p>
<p><em>Continuaci&oacute;n de la p&aacute;gina anterior.</em></p>
<p><img src="https://l10preunestawamb.blob.core.windows.net/lpa/images/legacy/201506/662x372a_0514101960.jpg" alt="" /></p>
<p><em>Carta de D. Juan Gich, Gerente del CF Barcelona y miembro del Comit&eacute; de la Copa de Ferias al Secretario General de la UD Las Palmas, D. Jes&uacute;s Garc&iacute;a Panasco, inform&aacute;ndole sobre la Asamblea General de la Copa de Ferias que tendr&iacute;a lugar&nbsp; el 11 de junio en Budapest.</em></p>
<p>&nbsp;</p>
<p><img src="https://l10preunestawamb.blob.core.windows.net/lpa/images/legacy/201506/662x372a_0514112661.jpg" alt="" /></p>
<p><em>Certificado de la UD Las Palmas comisionando al Secretario General, D. Jes&uacute;s Garc&iacute;a Panasco, a efectos de representar al club&nbsp; en la asamblea de Budapest de la Copa de Ciudades en Feria.</em></p>
<p><img src="https://l10preunestawamb.blob.core.windows.net/lpa/images/legacy/201506/662x372a_0514120062.jpg" alt="" /></p>
<p><em>Carta del Real Zaragoza CD dirigida al presidente de la UD Las Palmas, D. Juan Trujillo Febles, congratulando a nuestro equipo por su inclusi&oacute;n en la Copa de Ferias.</em></p>
<p><img src="https://l10preunestawamb.blob.core.windows.net/lpa/images/legacy/201506/662x372a_0514123163.jpg" alt="" /></p>
<p><em>Carta de la Agrupaci&oacute;n Espa&ntilde;ola de Periodistas Deportivos felicitando a la UD Las Palmas por su participaci&oacute;n en la Copa de Ferias.</em></p>
<p><img src="https://l10preunestawamb.blob.core.windows.net/lpa/images/legacy/201506/662x372a_0514130564.jpg" alt="" /></p>
<p><em>Telegrama del Secretario General, D. Jes&uacute;s Garc&iacute;a Panasco, desde Budapest comunicando a la Junta Directiva la inclusi&oacute;n de la UD Las Palmas en la Copa de Ferias.</em></p>
<p><img src="https://l10preunestawamb.blob.core.windows.net/lpa/images/legacy/201506/662x372a_0514133765.jpg" alt="" /></p>
<p><em>Carta del Sr. Juan Gich, Gerente del CF Barcelona, ofreciendo la direcci&oacute;n de dos informadores con amplios conocimientos del Hertha de Berl&iacute;n.</em></p>
<p><img src="https://l10preunestawamb.blob.core.windows.net/lpa/images/legacy/201506/662x372a_0514141166.jpg" alt="" /></p>
<p><em>Carta del entrenador de la UD Las Palmas, Luis Molowny, al periodista espa&ntilde;ol residente en Colonia Carlos Bibrian.</em></p>
<p><img src="https://l10preunestawamb.blob.core.windows.net/lpa/images/legacy/201506/662x372a_0514144767.jpg" alt="" /></p>
<p><em>Carta del periodista Carlos Bibrian ofreciendo informaci&oacute;n del Hertha de Berl&iacute;n al entrenador de la UD Las Palmas, Luis Molowny</em></p>
<p><img src="https://l10preunestawamb.blob.core.windows.net/lpa/images/legacy/201506/662x372a_0514152468.jpg" alt="" /></p>
<p><em>Continuaci&oacute;n de la p&aacute;gina anterior.</em></p>
<p><img src="https://l10preunestawamb.blob.core.windows.net/lpa/images/legacy/201506/662x372a_0514155869.jpg" alt="" /></p>
<p><em>Carta del Secretario General, D. Jes&uacute;s Garc&iacute;a Panasco, al presidente del Hertha de Berl&iacute;n ofreci&eacute;ndole informaci&oacute;n sobre el plan de viaje y estancia en la isla de Gran Canaria.</em></p>
<p>&nbsp;</p>
<p>&nbsp;</p>
<p><img src="https://l10preunestawamb.blob.core.windows.net/lpa/images/legacy/201506/662x372a_0514163170.jpg" alt="" /></p>
<p><img src="https://l10preunestawamb.blob.core.windows.net/lpa/images/legacy/201506/662x372a_0514180071.jpg" alt="" /></p>
<p><em>Traducci&oacute;n de la carta en alem&aacute;n del Herha de Berl&iacute;n, en la parte superior, informando a la UD Las Palmas sobre su desplazamiento a la isla.</em></p>
<p><img src="https://l10preunestawamb.blob.core.windows.net/lpa/images/legacy/201506/662x372a_0514195472.jpg" alt="" /></p>
<p><em>Certificado de la RFEF comunicando a la UD Las Palmas el tr&iacute;o arbitral de nacionalidad portuguesa que dirigir&iacute;a el encuentro UD Las Palmas-Hertha de Berl&iacute;n en el Estadio Insular.</em></p>
<p><img src="https://l10preunestawamb.blob.core.windows.net/lpa/images/legacy/201506/662x372a_0514203373.jpg" alt="" /></p>
<p><em>En una carta, deteriorada por el transcurso del tiempo, el periodista afincado en Colonia Carlos Bibrian informa sobre el encuentro Rot Weiss-Hertha de Berl&iacute;n, jugado con anterioridad.</em></p>
<p><img src="https://l10preunestawamb.blob.core.windows.net/lpa/images/legacy/201506/662x372a_0514210774.jpg" alt="" /></p>
<p><em>Continuaci&oacute;n de la p&aacute;gina anterior.</em></p>
<p><img src="https://l10preunestawamb.blob.core.windows.net/lpa/images/legacy/201506/662x372a_0514213975.jpg" alt="" /></p>
<p><em>Nota de la UD las Palmas a la Uni&oacute;n El&eacute;ctrica de Canarias.</em></p>
<p>&nbsp;</p>
<p><img src="https://l10preunestawamb.blob.core.windows.net/lpa/images/legacy/201506/662x372a_0514221376.jpg" alt="" /></p>
<p><em>Acuse de recibo del Gobierno Civil autorizando la celebraci&oacute;n del encuentro UD Las Palmas-Hertha de Berl&iacute;n.</em></p>
<p>&nbsp;</p>
<p>&nbsp;</p>
<p><img src="https://l10preunestawamb.blob.core.windows.net/lpa/images/legacy/201506/662x372a_0514225577.jpg" alt="" /></p>
<p><img src="https://l10preunestawamb.blob.core.windows.net/lpa/images/legacy/201506/662x372a_0514233078.jpg" alt="" /></p>
<p><em>Telegramas del gerente del CF Barcelona, Juan Gich, y del Delegado Nacional de Deportes, Juan Anntonio Samaranch, deseando toda clase de &eacute;xitos a nuestro equipo en la eliminatoria con el Hertha de Berl&iacute;n.</em></p>
<p><img src="https://l10preunestawamb.blob.core.windows.net/lpa/images/legacy/201506/662x372a_0514240179.jpg" alt="" /></p>
<p><em>La UD las Palmas agradece al c&oacute;nsul de Alemania la cesi&oacute;n del himno nacional de su pa&iacute;s.</em></p>
<p><img src="https://l10preunestawamb.blob.core.windows.net/lpa/images/legacy/201506/662x372a_0514243080.jpg" alt="" /></p>
<p><em>Saluda del C&oacute;nsul de Alemania, agradeciendo la invitaci&oacute;n al encuentro UD Las Palmas-Hertha de Berl&iacute;n.</em></p>
<p>El d&iacute;a 14 de septiembre de 1969 llegaba el Hertha de Berl&iacute;n, rival de la UD Las Palmas en la Copa de Ferias, al aeropuerto de Gando, marchando r&aacute;pidamente a su lugar de concentraci&oacute;n en el Hotel Reina Isabel del Puerto de La Luz.</p>
<p>Acompa&ntilde;aban a la expedici&oacute;n varios directivos del equipo y su entrenador Sr. Helmut Kronsbein.</p>
<p>Al d&iacute;a siguiente entrenar&iacute;an en el Estadio Insular en sesi&oacute;n matinal, realizando ejercicios diversos y un partidillo a lo largo del campo, dejando entre los presentes una buena impresi&oacute;n.</p>
<p>El Hertha desplazar&iacute;a a diecisiete jugadores en su totalidad: Gross y Fraydl, guardametas; Gross L., Patzke, Witt, Enders y Ferenl, defensas; Altenderif, Gayer e Ipta, medios y Steffenhagn, Brunsq, Horn, Kriegl, Weher y Bredenfeld, delanteros.</p>
<p><img src="https://l10preunestawamb.blob.core.windows.net/lpa/images/legacy/201506/662x372a_0514321781.jpg" alt="" /></p>
<p><em>Cartel del encuentro UD Las Palmas-Hertha de Berl&iacute;n.</em></p>
<p><img src="https://l10preunestawamb.blob.core.windows.net/lpa/images/legacy/201506/662x372a_0514324282.jpg" alt="" /></p>
<p><em>Datos de archivo del Hertha de Berl&iacute;n.</em></p>
<p><img src="https://l10preunestawamb.blob.core.windows.net/lpa/images/legacy/201506/662x372a_0514330983.jpg" alt="" /></p>
<p><em>Estad&iacute;stica dek Hertha de Berl&iacute;n en la Bundesliga.</em></p>
<p><img src="https://l10preunestawamb.blob.core.windows.net/lpa/images/legacy/201506/662x372a_0514335884.jpg" alt="" /></p>
<p><em>Formaci&oacute;n titular del conjunto alem&aacute;n.</em></p>
<p>Llegaba la primera confrontaci&oacute;n internacional de nuestro equipo. Despu&eacute;s de muchos contratiempos nuestro club era incluido en Budapest en el seno de la Copa de Ciudades en Feria, m&aacute;s adelante denominada UEFA, por estar tutelada por este organismo.</p>
<p align="center">&nbsp;</p>
<p>&nbsp;</p>
<p style="text-align: center;"><img src="https://l10preunestawamb.blob.core.windows.net/lpa/images/legacy/201506/662x372a_0514343285.jpg" alt="" /></p>
<p style="text-align: center;">&nbsp;</p>
<p><strong>Contratiempo inesperado ante el Hertha de Berl&iacute;n.</strong></p>
<p><strong>Los atacantes isle&ntilde;os no pudieron doblegar la f&eacute;rrea defensa alemana. </strong></p>
<p><strong>Juanito Guedes, de nuevo expulsado.</strong></p>
<p>&nbsp;</p>
<p>En declaraciones efectuadas por el equipo alem&aacute;n en los d&iacute;as previos al encuentro, ya nos dejaban entrever la posibilidad de obtener un resultado positivo aunque fuera una derrota por la m&iacute;nima.</p>
<p>El equipo alem&aacute;n nos daba un claro ejemplo de sinceridad, modestia y deportividad. Sinceridad al no esconderse a la hora de pedir acreditaci&oacute;n y palco con la finalidad de presenciar el encuentro UD Las Palmas-Elche; su petici&oacute;n fue sin tapujos ni m&aacute;scaras de inc&oacute;gnito&nbsp; como tan acostumbrados estamos en el f&uacute;tbol espa&ntilde;ol; modestia porque a pesar de ser un equipo que integra la Primera Divisi&oacute;n alemana y con varios internacionales en sus filas, fueron extremadamente moderados y respetuosos en sus declaraciones; deportivos porque aunque laboriosos en las tareas defensivas y disciplina t&aacute;ctica, no se emplearon con dureza o malas intenciones.</p>
<p>&nbsp;<img src="https://l10preunestawamb.blob.core.windows.net/lpa/images/legacy/201506/662x372a_0515085486.jpg" alt="" /></p>
<p><em>Formaci&oacute;n de la UD Las Palmas en su debut internacional en la Copa de Ferias ante el Hertha de Berl&iacute;n.</em></p>
<p><em>De pi&eacute;, de izquierda a dercha: Oregui, Mart&iacute;n II, Tonono, Hern&aacute;ndez, Castellano y Guedes.</em></p>
<p><em>De rodillas: Le&oacute;n, Gilberto II, Trona, Germ&aacute;n y Gilberto I.</em></p>
<p>&nbsp;<img src="https://l10preunestawamb.blob.core.windows.net/lpa/images/legacy/201506/662x372a_0515100687.jpg" alt="" /></p>
<p><em>Componentes del Hertha de Berl&iacute;n que alinear&iacute;a a: Fraydl, Enders, Witt, Patzke, Gross,&nbsp; Ferschl,&nbsp; Altendorff , Ipta, Horr, Gayer y Stoffenhaguen.</em></p>
<p>&nbsp;<img src="https://l10preunestawamb.blob.core.windows.net/lpa/images/legacy/201506/662x372a_0515102888.jpg" alt="" /></p>
<p><em>Los capitanes de la UD las Palmas y el Hertha de Berl&iacute;n, Juanito Guedes y Altendorff, intercambian presentes ante la atenta mirada del colegiado portugu&eacute;s Sr. D&iacute;az Nunes.</em></p>
<p>&nbsp;</p>
<p>El Hertha vino con un planteamiento defensivo aunque al ver c&oacute;mo transcurr&iacute;a el encuentro adelantaron sus l&iacute;neas llevando r&aacute;pidos contraataques al &aacute;rea peque&ntilde;a donde Oregui se mostraba muy atento y seguro.</p>
<p>El eje central del once alem&aacute;n nos dejar&iacute;a una impresi&oacute;n inmejorable, cortando todos los balones que llegaban a su &aacute;rea con suficiencia y energ&iacute;a. Tambi&eacute;n habr&iacute;a que significar que los atacantes isle&ntilde;os erraron una y otra vez, cargando el juego por el centro y rara vez por las bandas.</p>
<p>El equipo alem&aacute;n superaba en rapidez al once canario anticip&aacute;ndose en la mayor&iacute;a de los balones divididos y mayor velocidad de sus extremos.</p>
<p>No se debe, a nuestro entender, participar en un torneo europeo de tanta solera y prestigio como la Copa de Ferias&nbsp; -con todo lo que ello representaba para nuestra ciudad-&nbsp; jugando a medio gas y con una lentitud extremada. Era nuestro debut oficial en un torneo europeo y quiz&aacute;s por ello los aficionados saldr&iacute;an de nuestro estadio algo decepcionados.</p>
<p>Ni que decir tiene que despu&eacute;s de este primer encuentro favorable a los intereses del equipo alem&aacute;n, la vuelta en Berl&iacute;n se hac&iacute;a muy cuesta arriba para nuestros jugadores. Si a ello se le a&ntilde;ade la nueva expulsi&oacute;n de Juanito Guedes&hellip;</p>
<p>Resultaba realmente dif&iacute;cil de entender que a un jugador que ven&iacute;a de una fuerte sanci&oacute;n y despu&eacute;s de tit&aacute;nicos esfuerzos para conseguir la anulaci&oacute;n de su inhabilitaci&oacute;n cayera de nuevo en el mismo error dejando al equipo con diez jugadores en el terreno de juego.</p>
<p>El caso tomaba proporciones alarmantes debido a la reincidencia, ya que&nbsp; este jugador era el capit&aacute;n que deb&iacute;a en todo momento dar ejemplo de mesura y tranquilidad.</p>
<p><img src="https://l10preunestawamb.blob.core.windows.net/lpa/images/legacy/201506/662x372a_0515115689.jpg" alt="" /></p>
<p><em>El capit&aacute;n amarillo, Juanito Guedes, era un jugador excepcional. Muchacho sencillo, gozaba del aprecio de los aficionados, que supieron reconocerle sus excelentes cualidades futbol&iacute;sticas y grandes valores humanos. Sin embargo, era tanto su ardor en la cancha en defensa de los colores amarillos que en ocasiones se sobrepasaba en su &iacute;mpetu infringiendo los c&oacute;digos de comportamiento en el juego.</em></p>
<p>Sin embargo, no justifiquemos en este incidente el bajo rendimiento del equipo ya que la expulsi&oacute;n de Juanito Guedes tuvo&nbsp; lugar a mediados del segundo tiempo, que, parad&oacute;jicamente fue cuando se jug&oacute; mejor.</p>
<p>En esta fase final del encuentro el interior tinerfe&ntilde;o Gilberto II se crec&iacute;a ante la adversidad tratando de sustituir el hueco dejado por nuestro capit&aacute;n.</p>
<p><img src="https://l10preunestawamb.blob.core.windows.net/lpa/images/legacy/201506/662x372a_0515122490.jpg" alt="" /></p>
<p><em>Gilberto II.</em></p>
<p>Si bien es verdad que en&nbsp; estos minutos finales nuestro equipo tuvo alguna oportunidad, especialmente en aquella posible mano del defensa&nbsp; Witt que el &aacute;rbitro portugu&eacute;s D&iacute;az Nunes no consider&oacute; intencionada, no es menos cierto que las mejores ocasiones de gol las tuvo el equipo del Hertha y que gracias a la actuaci&oacute;n de Oregui, muy seguro toda la noche en sus intervenciones y salidas anticip&aacute;ndose a los delanteros germanos, pudimos capear el temporal.</p>
<p><img src="https://l10preunestawamb.blob.core.windows.net/lpa/images/legacy/201506/662x372a_0515125191.jpg" alt="" /></p>
<p><em>El guardameta Oregui ser&iacute;a el mejor jugador de la UD las Palmas en nuestro debut internacional ante el Hertha de Berl&iacute;n.</em></p>
<p>La delantera canaria rendir&iacute;a muy por debajo de sus posibilidades. De igual forma la l&iacute;nea media no estar&iacute;a acertada ya que a Guedes se le not&oacute; falto de ritmo hasta su expulsi&oacute;n y Castellano algo irregular en las entregas, aunque es justo significar que sub&iacute;a a todos los remates y fue de los que m&aacute;s ardor puso en la cancha.</p>
<p><img src="https://l10preunestawamb.blob.core.windows.net/lpa/images/legacy/201506/662x372a_0515132092.jpg" alt="" /></p>
<p><em>De pi&eacute;, de izquierda a derecha: Guedes y Castellano. </em></p>
<p><em>De rodillas: Germ&aacute;n y Tonono.</em></p>
<p>&nbsp;</p>
<p>La retaguardia canaria formada por Oregui, Mart&iacute;n, Tonono y Hern&aacute;ndez ser&iacute;a la m&aacute;s regular.</p>
<p>Ante la atenta mirada del &aacute;rbitro Jos&eacute; Rosa D&iacute;az Nunes los dos equipos presentar&iacute;an las siguientes formaciones:</p>
<p><img src="https://l10preunestawamb.blob.core.windows.net/lpa/images/legacy/201506/662x372a_05151407202.jpg" alt="" /></p>
<p><em>El &aacute;rbitro de la contienda Sr. D&iacute;az Nunes.</em></p>
<p>UD Las Palmas: Oregui; Mart&iacute;n II, Tonono, Hern&aacute;ndez; Castellano, Guedes; Le&oacute;n, Gilberto II, Trona, Germ&aacute;n y Gilberto I.</p>
<p>Hertha de Berl&iacute;n: Fraydl; Enders, Witt, Patzke; Gross L., Ferschl; Altendorff (Bredenfeld), Ipta, Horr, Gayer y Stoffenhaguen.</p>
<p>Radio Atl&aacute;ntico retransmit&iacute;a el encuentro en la voz del entra&ntilde;able locutor Pascual Calabuig.</p>
<p><img src="https://l10preunestawamb.blob.core.windows.net/lpa/images/legacy/201506/662x372a_0515143393.jpg" alt="" /></p>
<p><em>Pascual Calabuig.</em></p>
<p><img src="https://l10preunestawamb.blob.core.windows.net/lpa/images/legacy/201506/662x372a_0515150494.jpg" alt="" /></p>
<p><em>Recaudaci&oacute;n de localidades del encuentro de Copa de Ferias entre la UD Las Palmas y el Hertha de Berl&iacute;n.</em></p>
<p><img src="https://l10preunestawamb.blob.core.windows.net/lpa/images/legacy/201506/662x372a_0515154895.jpg" alt="" /></p>
<p><em>Borrador de la relaci&oacute;n de gastos del encuentro de la Copa de Ferias escrito a mano pr el Secretario General Jes&uacute;s Garc&iacute;a Panasco.</em></p>
<p>&nbsp;</p>
<p><strong>Visitantes isle&ntilde;os en el Hotel Internacional.</strong></p>
<p>La expedici&oacute;n amarilla volv&iacute;a a su lugar de concentraci&oacute;n para esperar su viaje a Madrid a efectos de medir sus fuerzas con el Atl&eacute;tico.</p>
<p>El equipo canario se hospedar&iacute;a como siempre en el Hotel Internacional. Con la expedici&oacute;n amarilla hab&iacute;a venido el doctor Tom&eacute; en compa&ntilde;&iacute;a de su esposa, habituales &nbsp;en los viajes del equipo desde la llegada de Luis Molowny.</p>
<p><img src="https://l10preunestawamb.blob.core.windows.net/lpa/images/legacy/201506/662x372a_0515162196.jpg" alt="" /></p>
<p><em>Dr. Emilio Tom&eacute;.</em></p>
<p><img src="https://l10preunestawamb.blob.core.windows.net/lpa/images/legacy/201506/662x372a_0515170897.jpg" alt="" /></p>
<p><em>Phyllis Head, esposa del Dr. Emilio Tom&eacute;, en animada charla con el extremo amarillo Mam&eacute; Le&oacute;n.</em></p>
<p><img src="https://l10preunestawamb.blob.core.windows.net/lpa/images/legacy/201506/662x372a_0515173798.jpg" alt="" /></p>
<p><em>El jugador, Guillermo Hern&aacute;ndez, vistiendo el uniforme del club en su "bautizo de aire". En su chaqueta se aprecia el primer escudo del club, obra de D. Sim&oacute;n Doreste Doreste.</em></p>
<p>Los jugadores Mart&iacute;n y Gilberto I eran duda hasta &uacute;ltima hora aunque todos los expedicionarios esperaban su concurso. De todas formas el t&eacute;cnico canario hab&iacute;a manifestado que con la expedici&oacute;n viajar&iacute;a el defensa Jos&eacute; Luis y el extremo Lemes que pod&iacute;an suplir perfectamente sus puestos.</p>
<p><img src="https://l10preunestawamb.blob.core.windows.net/lpa/images/legacy/201506/662x372a_0515181099.jpg" alt="" /></p>
<p><em>El masajista &nbsp;de la UD Las Palmas, Pepe Gonz&aacute;lez, coloca un vendaje en la pierna dolorida de Gilberto I. </em></p>
<p>Un gran n&uacute;mero de visitantes isle&ntilde;os se daban cita en el hotel de concentraci&oacute;n de la UD Las Palmas para saludar a la expedici&oacute;n canaria. Entre ellos destacaban dos antiguos miembros de la Ponencia de Fusi&oacute;n y Primera Gestora del club como eran Francisco Naranjo Hermosilla, de negocios en Madrid, y Luis Gonz&aacute;lez Vera, actual delegado de nataci&oacute;n de la UD las Palmas, que regresaba de Barcelona, donde hab&iacute;a asistido a los campeonatos de Espa&ntilde;a de nataci&oacute;n.</p>
<p><img src="https://l10preunestawamb.blob.core.windows.net/lpa/images/legacy/201506/662x372a_05151838100.jpg" alt="" /></p>
<p><em>Francisco Naranjo Hermosilla.</em></p>
<p><img src="https://l10preunestawamb.blob.core.windows.net/lpa/images/legacy/201506/662x372a_05151922101.jpg" alt="" /></p>
<p><em>Luis Gonz&aacute;lez Vera.</em></p>
<p>De igual forma, el ex entrenador del equipo amarillo Arsenio Arocha, residente en la capital de Espa&ntilde;a, los directivos Pedro Valido Ben&iacute;tez, segundo representante del equipo isle&ntilde;o en Madrid tras la marcha de Jos&eacute; Luis L&oacute;pez, Atilio Ley Duarte y Fernando Arencibia; el ex jugador de la UD Las Palmas, Juli&aacute;n Mesa, que por aquellas fechas defend&iacute;a los colores del Avil&eacute;s y,&nbsp; sobre todo, muchos estudiantes en busca de localidades.</p>
<p>&nbsp;</p>
<p><img src="https://l10preunestawamb.blob.core.windows.net/lpa/images/legacy/201506/662x372a_05152004102.jpg" alt="" /></p>
<p><em>Arsenio Arocha.</em></p>
<p><img src="https://l10preunestawamb.blob.core.windows.net/lpa/images/legacy/201506/662x372a_05152030103.jpg" alt="" /></p>
<p><em>Atilio Ley Duarte.</em></p>
<p><img src="https://l10preunestawamb.blob.core.windows.net/lpa/images/legacy/201506/662x372a_05152100104.jpg" alt="" /></p>
<p><em>Fernando Arencibia.</em></p>
<p><img src="https://l10preunestawamb.blob.core.windows.net/lpa/images/legacy/201506/662x372a_05152130105.jpg" alt="" /></p>
<p><em>Juli&aacute;n Mesa.</em></p>
<p>&nbsp;</p>
<p>&nbsp;</p>
<p style="text-align: center;"><img src="https://l10preunestawamb.blob.core.windows.net/lpa/images/legacy/201506/662x372a_05152210106.jpg" alt="" />&nbsp;</p>
<p>&nbsp;</p>
<p><strong>La UD Las Palmas, l&iacute;der de Primera Divisi&oacute;n tras derrotar al Atl&eacute;tico de Madrid en el Estadio de Manzanares.</strong></p>
<p><strong>Soberbio gol de Le&oacute;n desde dif&iacute;cil &aacute;ngulo dando el bal&oacute;n en los dos postes antes de entrar en la red.</strong></p>
<p><strong>En las postrimer&iacute;as del encuentro Trona establec&iacute;a el tanto de la victoria canaria.</strong></p>
<p>Trabajada victoria del equipo amarillo en el Estadio del Manzanares.</p>
<p>Un primer tiempo de absoluto dominio canario con ventaja en el marcador desde los diez minutos de juego al establecer el extremo Le&oacute;n el primer gol del encuentro y un segundo periodo muy irregular de nuestro equipo, salvo la jugada que propiciar&iacute;a el gol del espigado delantero Trona.</p>
<p><img src="https://l10preunestawamb.blob.core.windows.net/lpa/images/legacy/201506/662x372a_05152258107.jpg" alt="" /></p>
<p><em>Le&oacute;n.</em></p>
<p>En la primera fase, la UD Las Palmas pudo aumentar su ventaja march&aacute;ndose al descanso con una victoria holgada, dado que a pesar de las grandes individualidades atl&eacute;ticas, la superioridad t&eacute;cnica del conjunto isle&ntilde;o fue evidente.</p>
<p>Hab&iacute;an transcurrido diez minutos de juego cuando Guedes recibe el bal&oacute;n y tras adelantarlo unos metros pasa a Germ&aacute;n, que regatea a Iglesias y Jayo, tirando raso a la izquierda del guardameta rojiblanco Zubiarrain, quien despeja el bal&oacute;n al lugar donde se encontraba Le&oacute;n que ven&iacute;a en carrera, rematando con gran habilidad a la red. El bal&oacute;n da en un poste, en otro, y finalmente se cuela en la red.</p>
<p><img src="https://l10preunestawamb.blob.core.windows.net/lpa/images/legacy/201506/662x372a_05152332108.jpg" alt="" /></p>
<p><em>Zubiarrain.</em></p>
<p>Pudo entonces la UD las Palmas sacar m&aacute;s provecho de su dominio absoluto ya que poco despu&eacute;s del gol de Le&oacute;n, un excelente cabezazo de Gilberto II, anticip&aacute;ndose a Jayo, saldr&iacute;a rozando el larguero.</p>
<p>Bien es verdad que se not&oacute; la ausencia de Mart&iacute;n II ya que Hern&aacute;ndez no era lateral derecho ni ten&iacute;a la facilidad de proyectarse en ataque como el defensa tinerfe&ntilde;o. En la banda izquierda, Jos&eacute; Luis le fue cogiendo el tono al encuentro sin salir de su demarcaci&oacute;n habitual ya que Ufarte tend&iacute;a a irse al centro. El l&iacute;bero canario, Tonono, al igual que Castellano y el meta Oregui realizaron un excelente encuentro.</p>
<p>En el segundo tiempo se producir&iacute;a un baj&oacute;n en los amarillos.</p>
<p>El guardameta Oregui se convertir&iacute;a de nuevo en el h&eacute;roe de la jornada. A todo ello habr&iacute;a que sumar la expulsi&oacute;n de Germ&aacute;n al repeler una agresi&oacute;n de Iglesias que hab&iacute;a estado incurriendo en alevosas entradas todo el encuentro. Se daba la circunstancia que tras la expulsi&oacute;n de Juanito Guedes ante el Hertha de Berl&iacute;n, Germ&aacute;n era el segundo jugador expulsado en cinco d&iacute;as.</p>
<p><img src="https://l10preunestawamb.blob.core.windows.net/lpa/images/legacy/201506/662x372a_05152400109.jpg" alt="" /></p>
<p><em>Germ&aacute;n.</em></p>
<p><img src="https://l10preunestawamb.blob.core.windows.net/lpa/images/legacy/201506/662x372a_05152425110.jpg" alt="" /></p>
<p><em>Iglesias.</em></p>
<p>A los pocos minutos de la expulsi&oacute;n, todo el Atl&eacute;tico en campo canario bombeaba balones sobre el &aacute;rea de Oregui. El bal&oacute;n llega a la l&iacute;nea media donde Gilberto I inicia una veloz galopada advirtiendo la situaci&oacute;n de Trona, que con gran zancada hab&iacute;a llegado al &aacute;rea rojiblanca. El extremo le lanza un centro preciso que el ariete controla con gran maestr&iacute;a para luego rematar con contundencia a puerta un tiro cruzado y raso.</p>
<p>Pasado el tiempo reglamentario se produce un c&oacute;rner contra el marco canario. El bal&oacute;n no llega a despejarlo Oregui y es rechazado por Hern&aacute;ndez, flojo, ante varios jugadores atl&eacute;ticos, cayendo finalmente a los pies del extremo Alberto, que aprovecha para marcar.</p>
<p><img src="https://l10preunestawamb.blob.core.windows.net/lpa/images/legacy/201506/662x372a_05152533111.jpg" alt="" /></p>
<p><em>Alberto.</em></p>
<p>En definitiva, buen triunfo del equipo amarillo ante la presencia de muchos seguidores canarios, preferentemente soldados de Aviaci&oacute;n de la Base de El Pinar de Valladolid.</p>
<p>Ante la presencia del &aacute;rbitro del colegio extreme&ntilde;o, Pedro S&aacute;nchez Ib&aacute;&ntilde;ez, los equipos presentaron las siguientes formaciones:</p>
<p>Atl&eacute;tico de Madrid: Zubiarrain; Melo, Jayo, Calleja; Irureta, Iglesias (Orozco); Ufarte, Luis, G&aacute;rate, Adelardo (Juan Antonio) y Alberto.</p>
<p>UD Las Palmas: Oregui; Hern&aacute;ndez, Tonono, Jos&eacute; Luis; Castellano, Guedes; Le&oacute;n, Gilberto II, Trona, Germ&aacute;n y Gilberto I.</p>
<p>Por aquellas mismas fechas, Hern&aacute;ndez y Trona, eran llamados a la concentraci&oacute;n de Kubala. &nbsp;Las dos j&oacute;venes promesas canarias estar&iacute;an en la lista definitiva de la Sub-23 para el partido con Italia.</p>
<p><img src="https://l10preunestawamb.blob.core.windows.net/lpa/images/legacy/201506/662x372a_05152611112.jpg" alt="" /></p>
<p><em>Los jugadores de la UD Las Palmas, Hern&aacute;ndez y Trona, muestran su alegr&iacute;a al ser convocados por Ladislao Kubala.</em></p>
<p><img src="https://l10preunestawamb.blob.core.windows.net/lpa/images/legacy/201506/662x372a_05152645205.jpg" alt="" /></p>
<p><em>Nota de agradecimiento de la Junta Directiva del &nbsp;Atl&eacute;tico de Madrid dirigida a la UD las Palmas al obtener el Campeonato de Liga 1969/70.</em></p>
<p>&nbsp;</p>
<p><strong>El Real Madrid concita una gran expectaci&oacute;n a su llegada a la isla.</strong></p>
<p>Con el vicepresidente Sr. Lasarreta como jefe de la expedici&oacute;n, acompa&ntilde;ado del directivo Sr. Mariano Urz&aacute;iz, duque de Villahermosa, viajaban el entrenador Miguel Mu&ntilde;oz, el masajista Legido, encargado de material y un total de quince jugadores:</p>
<p>Betancor, Junquera, Calpe, De Felipe, Sanch&iacute;s, Babiloni, Pirri, Zoco, Fleitas, Amancio, Grosso, Vel&aacute;zquez, Gento, Jos&eacute; Luis y Grande.</p>
<p>El equipo eleg&iacute;a esta vez el Hotel Helios como lugar de concentraci&oacute;n.</p>
<p><img src="https://l10preunestawamb.blob.core.windows.net/lpa/images/legacy/201506/662x372a_05152748114.jpg" alt="" /></p>
<p><em>El Gerente del Real Madrid, A. Calder&oacute;n, solicita al Secretario General, D. Jes&uacute;s Garc&iacute;a Panasco, informes sobre el Hotel Helios tras romper sus relaciones con el Hotel Parque por pertenecer a la H.U.S.A..</em></p>
<p><img src="https://l10preunestawamb.blob.core.windows.net/lpa/images/legacy/201506/662x372a_05152814115.jpg" alt="" /></p>
<p><em>Expedici&oacute;n del Real Madrid en su visita del a&ntilde;o anterior al Hotel Parque.</em></p>
<p><img src="https://l10preunestawamb.blob.core.windows.net/lpa/images/legacy/201506/662x372a_05152937116.jpg" alt="" /></p>
<p><em>Los guardametas madridistas, Antonio Betancor y Junquera posando para la instant&aacute;nea de Hern&aacute;ndez Gil.</em></p>
<p><img src="https://l10preunestawamb.blob.core.windows.net/lpa/images/legacy/201506/662x372a_05153015117.jpg" alt="" /></p>
<p><em>El guardameta internacional canario en las filas del Real Madrid, Antonio Betancor, posando para la c&aacute;mara de Hern&aacute;ndez Gil con semblante risue&ntilde;o.</em></p>
<p>La UD Las Palmas sub&iacute;a como siempre a Tafira, hosped&aacute;ndose en el Hotel Santa Br&iacute;gida, lugar de tantos recuerdos para el equipo isle&ntilde;o.</p>
<p>Los jugadores concentrados ser&iacute;an los siguientes:</p>
<p>Oregui, Catal&aacute;, Mart&iacute;n, Hern&aacute;ndez, Tonono, Jos&eacute; Luis, Castellano, Guedes, Niz, Le&oacute;n, Gilberto II, Trona, Jos&eacute; Juan, Gilberto I y Menchu.</p>
<p><img src="https://l10preunestawamb.blob.core.windows.net/lpa/images/legacy/201506/662x372a_05153047118.jpg" alt="" /></p>
<p><em>Los jugadores Gilberto I, Mart&iacute;n II, Castellano, Jos&eacute; Juan y Germ&aacute;n, durante una concentraci&oacute;n.</em></p>
<p><img src="https://l10preunestawamb.blob.core.windows.net/lpa/images/legacy/201506/662x372a_05153121119.jpg" alt="" /></p>
<p>Como bien nos narraba el estimado periodista Antonio Lemus en su cr&oacute;nica titulada "Cada d&iacute;a" - tantos a&ntilde;os en la p&aacute;gina de deportes- la UD Las Palmas recib&iacute;a al Real Madrid bajo un clima de gran expectaci&oacute;n y la desconfianza de no haber ganado al Real Madrid en toda su historia deportiva. La vez que m&aacute;s cerca hab&iacute;amos estado de ello fue en la temporada 1954/55 despu&eacute;s de nuestro retorno a Primera Divisi&oacute;n, cuando a pocos minutos del final y con ventaja en el marcador, un clamoroso desplazamiento de Marquitos a Pep&iacute;n propiciaba el gol de Luis Molowny que igualar&iacute;a la contienda.</p>
<p><img src="https://l10preunestawamb.blob.core.windows.net/lpa/images/legacy/201506/662x372a_05153218120.jpg" alt="" /></p>
<p><em>Temporada 1954/55. En la instant&aacute;nea, los jugadores del Real Madrid saltan al campo del Estadio Insular. En primer plano, el defensa Marquitos y el medio Miguel Mu&ntilde;oz.</em></p>
<p><img src="https://l10preunestawamb.blob.core.windows.net/lpa/images/legacy/201506/662x372a_05153255121.jpg" alt="" /></p>
<p>El gol fantasma de Molowny.</p>
<p><em>El d&iacute;a 9 de enero de 1955, el equipo amarillo fue privado de una clara victoria sobre el Real Madrid por el colegiado Andr&eacute;s Rivero Lecuona. Cuando todos los aficionados canarios cantaban victoria en el entra&ntilde;able recinto de Ciudad Jard&iacute;n, el cuadro merengue consigue el tanto del empate en las postrimer&iacute;as del encuentro por medio de Molowny en clar&iacute;sima falta, al ser desplazado en su salida el guardameta Pep&iacute;n por el central madrile&ntilde;o Marquitos.</em></p>
<p>&nbsp;</p>
<p>&nbsp;</p>
<p><img src="https://l10preunestawamb.blob.core.windows.net/lpa/images/legacy/201506/662x372a_05153330122.jpg" alt="" /></p>
<p><em>Luis Molowny.</em></p>
<p><img src="https://l10preunestawamb.blob.core.windows.net/lpa/images/legacy/201506/662x372a_05153409123.jpg" alt="" /></p>
<p><em>El colegiado del encuentro, Sr. Rivero Lecuona se mostrar&iacute;a muy parcial durante todo el encuentro estando a punto de originar un altercado de orden p&uacute;blico al final del partido, tras el gol "fantasma" de Luis Molowny.</em></p>
<p>De igual forma,&nbsp; en la temporada 1967/68 que hab&iacute;a terminado igualmente en empate a dos tantos cuando ya se saboreaba la victoria.</p>
<p>El conjunto canario contaba con la sensible baja de Germ&aacute;n, expulsado en el anterior partido por agresi&oacute;n a Iglesias. Igualmente, la lesi&oacute;n que ven&iacute;a arrastrando el defensa Mart&iacute;n, que aunque recuperado, no ten&iacute;a la misma preparaci&oacute;n de sus compa&ntilde;eros.</p>
<p><img src="https://l10preunestawamb.blob.core.windows.net/lpa/images/legacy/201506/662x372a_05153436124.jpg" alt="" /></p>
<p><em>El masajista, Pepe Gonz&aacute;lez, durante una sesi&oacute;n de masaje con Mart&iacute;n II en el Hotel Santa Br&iacute;gida.</em></p>
<p>En el Madrid todos eran caras conocidas ya que hab&iacute;an jugado en el Estadio Insular tanto en el Real Madrid como en anteriores equipos. El paraguayo Fleitas era sin duda la novedad ya que la campa&ntilde;a anterior hab&iacute;a jugado con el M&aacute;laga, coloc&aacute;ndose al final de la temporada en uno de los primeros puestos de la clasificaci&oacute;n de goleadores.</p>
<p><img src="https://l10preunestawamb.blob.core.windows.net/lpa/images/legacy/201506/662x372a_05153501125.jpg" alt="" /></p>
<p><em>Fleitas.</em></p>
<p>Como espectador de excepci&oacute;n en este encuentro, el seleccionador Ladislao Kubala, que en recientes fechas hab&iacute;a convocado a los canarios Trona y Hern&aacute;ndez para el partido ante Italia en la categor&iacute;a Sub-23.</p>
<p><img src="https://l10preunestawamb.blob.core.windows.net/lpa/images/legacy/201506/662x372a_05153533126.jpg" alt="" /></p>
<p><em>El Seleccionador Nacional, Ladislao Kubala.</em></p>
<p>&nbsp;</p>
<p style="text-align: center;"><img src="https://l10preunestawamb.blob.core.windows.net/lpa/images/legacy/201506/662x372a_05153633127.jpg" alt="" />&nbsp;</p>
<p style="text-align: center;">&nbsp;</p>
<p><strong>Tras un comienzo fulgurante con ventaja de dos goles en el marcador, la UD las Palmas termina perdiendo el encuentro.</strong></p>
<p><strong>Paco Castellano desaprovecha la ocasi&oacute;n de marcar al fallar un penalti.</strong></p>
<p><img src="https://l10preunestawamb.blob.core.windows.net/lpa/images/legacy/201506/662x372a_05153710128.jpg" alt="" /></p>
<p><em>Alineaci&oacute;n que present&oacute; la UD las Palmas ante el Real Madrid en el Estadio Insular.</em></p>
<p><em>De izquierda a derecha, de pi&eacute;: Oregui, Hern&aacute;ndez, Tonono, Jos&eacute; Luis, Castellano y Guedes.</em></p>
<p><em>De rodillas: Le&oacute;n, Mart&iacute;n II, Trona, Gilberto II y Gilberto I.</em></p>
<p>&nbsp;</p>
<p><img src="https://l10preunestawamb.blob.core.windows.net/lpa/images/legacy/201506/662x372a_05153737129.jpg" alt="" /></p>
<p><em>Formaci&oacute;n del Real Madrid. De izquierda a derecha, de pi&eacute;: Betancor, Calpe, De Felipe, Sanch&iacute;s Pirri y Zoco. De rodillas: Fleitas, Amancio, Grosso, Vel&aacute;zquez y Gento.</em></p>
<p><img src="https://l10preunestawamb.blob.core.windows.net/lpa/images/legacy/201506/662x372a_05153806130.jpg" alt="" /></p>
<p><em>Banquillo UD Las Palmas: Catal&aacute;, Menchu, Jos&eacute; Juan, Emilio Tom&eacute;, Luis Molowny y Carmelo Campos.</em></p>
<p><img src="https://l10preunestawamb.blob.core.windows.net/lpa/images/legacy/201506/662x372a_05153834131.jpg" alt="" /></p>
<p><em>Banquillo Real Madrid: Legido (masajista), Babiloni, Miguel Mu&ntilde;oz, Jos&eacute; Luis, Grande y Junquera.</em></p>
<p><img src="https://l10preunestawamb.blob.core.windows.net/lpa/images/legacy/201506/662x372a_05153859132.jpg" alt="" /></p>
<p><em>Los capitanes de ambos equipos, Tonono y Gento, se saludan ante la presencia del tr&iacute;o arbitral.</em></p>
<p><img src="https://l10preunestawamb.blob.core.windows.net/lpa/images/legacy/201506/662x372a_05153926133.jpg" alt="" /></p>
<p><em>El &aacute;rbitro del encuentro Sr. Pascual Tejerina del Colegio Oeste.</em></p>
<p>Ni los m&aacute;s antiguos aficionados de nuestro equipo daban cr&eacute;dito a lo que estaban presenciando.</p>
<p>Por primera vez en la historia, la UD Las Palmas se pon&iacute;a con dos goles de ventaja a la media hora de juego ante el todopoderoso Real Madrid. Fue entonces cuando llegamos a creer en la posibilidad de derrotar al conjunto merengue, rompiendo el maleficio de anteriores confrontaciones a lo largo de la historia.</p>
<p>En la primera media hora de juego, la superioridad del equipo canario fue absoluta. La tripleta que cubr&iacute;a el medio campo, formada por Juanito Guedes, Gilberto II y Mart&iacute;n, bord&oacute; un f&uacute;tbol de aut&eacute;ntica clase, partiendo desde la l&iacute;nea defensiva para distribuir a los espadas isle&ntilde;os, Le&oacute;n y Gilberto I, que estuvieron r&aacute;pidos e incisivos, llevando mucho peligro al &aacute;rea del Madrid.</p>
<p>Cuando s&oacute;lo iban transcurridos cinco minutos de juego, Mart&iacute;n avanza por la derecha en posici&oacute;n de falso extremo y centra h&aacute;bilmente al extremo Le&oacute;n que se desplazaba habitualmente hacia el centro. El bal&oacute;n llega a las inmediaciones de Gilberto I quien ve la posici&oacute;n de Le&oacute;n como aut&eacute;ntico ariete y bombea el bal&oacute;n al &aacute;rea, cabeceando el siete amarillo a la red.</p>
<p><img src="https://l10preunestawamb.blob.core.windows.net/lpa/images/legacy/201506/662x372a_05153953134.jpg" alt="" /></p>
<p><em>El bal&oacute;n llega a las inmediaciones de Gilberto I, que centra sobre la porter&iacute;a madridista.</em></p>
<p>&nbsp;</p>
<p><img src="https://l10preunestawamb.blob.core.windows.net/lpa/images/legacy/201506/662x372a_05154051135.jpg" alt="" /></p>
<p>En la instant&aacute;nea, Le&oacute;n inaugura el marcador batiendo al guardameta madridista Betancor. En primer plano, el medio madridista Zoco parece dar alguna indicaci&oacute;n al juez de l&iacute;nea.</p>
<p><img src="https://l10preunestawamb.blob.core.windows.net/lpa/images/legacy/201506/662x372a_05154132136.jpg" alt="" /></p>
<p><em>El extremo amarillo, Le&oacute;n, corre a fundirse en un abrazo a Gilberto I.</em></p>
<p>Tras el gol, el equipo blanco trata de deshacerse de la presi&oacute;n de nuestros jugadores pero se ven impotentes ante el juego galvanizado y profundo de los amarillos que siguen creando situaciones de gol.</p>
<p>Fruto de este intenso dominio llega el segundo gol, al recibir Guedes un bal&oacute;n en el v&eacute;rtice izquierdo del campo. El denominado "Mariscal amarillo" avanza hacia la porter&iacute;a madridista y su centro-chut se cuela en la red de forma inesperada. El estadio es un aut&eacute;ntico clamor.</p>
<p><img src="https://l10preunestawamb.blob.core.windows.net/lpa/images/legacy/201506/662x372a_05154222137.jpg" alt="" /></p>
<p><em>Segundo gol de la UD Las Palmas obtenido por Juanito Guedes. </em></p>
<p>Los madridistas, perplejos ante aquella avalancha, se reprochaban su desorden en el terreno de juego donde todas sus l&iacute;neas eran continuamente desbordadas por nuestros jugadores. Sin embargo, un encuentro de f&uacute;tbol tiene noventa minutos de duraci&oacute;n y la UD Las Palmas hab&iacute;a realizado un esfuerzo tit&aacute;nico la primera media hora de juego.</p>
<p>Tras el segundo gol, lejos de acrecentarse y adquirir mayor confianza, el equipo se descompuso, observ&aacute;ndose un sensible baj&oacute;n en su juego. Las l&iacute;neas comenzaron a replegarse y perder balones en la zona de creaci&oacute;n. El nerviosismo parec&iacute;a atenazar a nuestros jugadores.</p>
<p>&nbsp;</p>
<p><img src="https://l10preunestawamb.blob.core.windows.net/lpa/images/legacy/201506/662x372a_05154306138.jpg" alt="" /></p>
<p><em>Los espectadores muestran su alborozo tras el segundo tanto amarillo.</em></p>
<p>Cuando s&oacute;lo faltaban siete minutos para la finalizaci&oacute;n de la primera mitad, el delantero madridista Grosso, completamente libre de marca, de gran disparo desde fuera del &aacute;rea, raso y cruzado, bate a Oregui, logrando reducir distancias en el marcador. El gol, a tan pocos minutos de la finalizaci&oacute;n del primer periodo debi&oacute; tener un efecto psicol&oacute;gico ya que sirvi&oacute; para insuflar y dar &aacute;nimos a los jugadores merengues y llevar el des&aacute;nimo y nerviosismo a los locales.</p>
<p><img src="https://l10preunestawamb.blob.core.windows.net/lpa/images/legacy/201506/662x372a_05154437204.jpg" alt="" /></p>
<p><em style="line-height: 1.4;">Grosso.</em></p>
<p>La UD Las Palmas, a pesar de ir por delante en el marcador, ve&iacute;a peligrar su ventaja, desmoron&aacute;ndose por momentos y comenzando a fallar en todas sus l&iacute;neas.</p>
<p><img src="https://l10preunestawamb.blob.core.windows.net/lpa/images/legacy/201506/662x372a_05154530139.jpg" alt="" /></p>
<p><em>Contrase&ntilde;a del club en el descanso del encuentro.</em></p>
<p>&nbsp;</p>
<p><img src="https://l10preunestawamb.blob.core.windows.net/lpa/images/legacy/201506/662x372a_05154607140.jpg" alt="" /></p>
<p><em>El entrenador auxiliar, Carmelo Campos, con semblante de preocupaci&oacute;n, encamina sus pasos hacia el vestuario amarillo en el descanso del partido.</em></p>
<p>La segunda parte ser&iacute;a la ant&iacute;tesis de la primera ya que el Madrid se erig&iacute;a en due&ntilde;o y se&ntilde;or del encuentro.</p>
<p>La zona ancha del campo, que en la primera mitad hab&iacute;a estado colosal con Mart&iacute;n, Guedes y Gilberto II, no pod&iacute;a en ning&uacute;n momento con la visi&oacute;n de juego y rapidez de Pirri, Grosso y Vel&aacute;zquez.</p>
<p>Con un juego vertical basado en paredes y abrir el juego a las bandas, el equipo merengue desbordaba una y otra vez al equipo canario, que cada vez se mostraba m&aacute;s cansino y lento en todas las l&iacute;neas.</p>
<p>Fruto del dominio constante del Madrid llegaba el segundo gol, obra de Vel&aacute;zquez, en una jugada genial sorteando a Mart&iacute;n, Guedes, Castellano y Tonono para colocar el bal&oacute;n al &aacute;ngulo cuando el guardameta Oregui iniciaba la salida.</p>
<p><img src="https://l10preunestawamb.blob.core.windows.net/lpa/images/legacy/201506/662x372a_05154813207.jpg" alt="" /></p>
<p><em>Vel&aacute;zquez.</em></p>
<p>El empate caer&iacute;a como un jarro de agua fr&iacute;a en la afici&oacute;n isle&ntilde;a, mostrando su malestar increpando a los jugadores. Era en cierta medida l&oacute;gico. La decepci&oacute;n era absoluta despu&eacute;s de ir ganando el encuentro c&oacute;modamente. La desmoralizaci&oacute;n se hac&iacute;a patente no s&oacute;lo en los jugadores sino en el repleto grader&iacute;o que presentaba el Estadio Insular.</p>
<p>Para agravar m&aacute;s la situaci&oacute;n, vino despu&eacute;s el penalti que el &aacute;rbitro apreci&oacute; en el &aacute;rea canaria, transformando magistralmente por el veterano extremo Gento.</p>
<p><img src="https://l10preunestawamb.blob.core.windows.net/lpa/images/legacy/201506/662x372a_05154858206.jpg" alt="" /></p>
<p><em>Gento.</em></p>
<p><img src="https://l10preunestawamb.blob.core.windows.net/lpa/images/legacy/201506/662x372a_05154936143.jpg" alt="" /></p>
<p><em>Semblante de perplejidad y decepci&oacute;n en los espectadores de Tribuna tras el tanto del veterano Gento.</em></p>
<p>Sin embargo, la decisi&oacute;n del Sr. Tejerina al apreciar igualmente mano en el &aacute;rea blanca llev&oacute; de nuevo la esperanza a las alica&iacute;das huestes amarillas y a una afici&oacute;n que esperaba impaciente la reacci&oacute;n del equipo.</p>
<p>Pero de salvar al menos un punto se pasa al naufragio m&aacute;s absoluto y todo hac&iacute;a prever que el Madrid aumentar&iacute;a su cuenta en el casillero.</p>
<p><strong>La pena m&aacute;xima m&aacute;s comentada en toda la historia del club.</strong></p>
<p>El penalti fallado por el secante amarillo Paco Castellano ante el Real Madrid ha sido posiblemente la pena m&aacute;xima m&aacute;s comentada en toda la historia del club, abri&eacute;ndose todo tipo de debates y conjeturas sobre el mismo, la mayor&iacute;a de ellas totalmente infundadas, haciendo mucho da&ntilde;o tanto al jugador como al t&eacute;cnico Luis Molowny.</p>
<p>Habr&iacute;a que remontarse a la semana previa al partido para comprender la aut&eacute;ntica verdad del caso.</p>
<p>El jugador Paco Castellano no sobresal&iacute;a precisamente por sus virtudes t&eacute;cnicas pero en los entrenamientos eran muy pocos los que le superaban en las penas m&aacute;ximas. El entrenador, Luis Molowny, hab&iacute;a venido ensayando durante toda la semana y el jugador luc&iacute;a el promedio m&aacute;s alto de goles efectuados de penalti salvo el especialista del equipo, Germ&aacute;n D&eacute;vora, que por castigo federativo se ve&iacute;a imposibilitado de participar en dicho encuentro.</p>
<p><img src="https://l10preunestawamb.blob.core.windows.net/lpa/images/legacy/201506/662x372a_05155052144.jpg" alt="" /></p>
<p><em>Luis Molowny dirigiendo el entrenamiento matinal en el Estadio Insular. En primer plano, Castellano y Oregui efectuando ejercicios f&iacute;sicos.</em></p>
<p><img src="https://l10preunestawamb.blob.core.windows.net/lpa/images/legacy/201506/662x372a_05155123145.jpg" alt="" /></p>
<p><em>Los jugadores de la UD Las Palmas se ejercitan en el Estadio Insular. </em></p>
<p><img src="https://l10preunestawamb.blob.core.windows.net/lpa/images/legacy/201506/662x372a_05155150146.jpg" alt="" /></p>
<p><em>El veterano entrenador auxiliar, Carmelo Campos, toda una instituci&oacute;n en el club amarillo.</em></p>
<p>Paco Castellano lanzaba las penas m&aacute;ximas con una potencia extraordinaria y con aceptable precisi&oacute;n. En los entrenamientos efectuados aquella misma semana no hab&iacute;a fallado un solo penalti, vi&eacute;ndose tanto Oregui como Catal&aacute; impotentes de atajar sus potentes disparos.</p>
<p><img src="https://l10preunestawamb.blob.core.windows.net/lpa/images/legacy/201506/662x372a_05155225147.jpg" alt="" /></p>
<p><em>El portero Catal&aacute; el d&iacute;a de su presentaci&oacute;n, muestra a los reporteros gr&aacute;ficos sus aut&eacute;nticos poderes.</em></p>
<p>&iquest;Pudo el t&eacute;cnico Luis Molowny elegir otro jugador? S&iacute;, por supuesto, pero no s&oacute;lo Castellano presentaba el mejor record de aciertos en los entrenamientos sino la predisposici&oacute;n a tirarlo, algo que muchos cr&iacute;ticos y aficionados no se han planteado.</p>
<p><strong>C&oacute;mo una falacia dicha muchas veces llega a convertirse en verdad.</strong></p>
<p>Desde que fue difundida la cr&oacute;nica del fallo del penalti de Castellano al Real Madrid la noticia correr&iacute;a como un reguero de p&oacute;lvora por toda la ciudad, creando opini&oacute;n en los aficionados que emit&iacute;an criterios que iban en un principio de la realidad a la ficci&oacute;n.</p>
<p>Tambi&eacute;n se pon&iacute;a en tela de juicio la honorabilidad y honradez de Luis Molowny aduciendo su pasado y vinculaci&oacute;n con el Real Madrid. Nada m&aacute;s falso y lejos de la realidad. Los que nos preciamos de haber conocido a Luis Molowny sabemos de su absoluta integridad tanto fuera como dentro de las canchas de juego.</p>
<p>Luis Molowny era aut&eacute;ntico paradigma en c&oacute;digos deontol&oacute;gicos y de conducta y comportamiento. Un hombre incapaz de elucubrar el m&aacute;s m&iacute;nimo pensamiento en contra de su club por mucho que se tratara del Real Madrid de sus amores.</p>
<p>De igual forma se ha tergiversado y falseado la ejecuci&oacute;n del penalti de Castellano con comentarios insidiosos y falacias de muy mal gusto. Cr&iacute;ticas y lecturas como: "&iexcl;El penalti lleg&oacute; a la Grada de Fedora! &iexcl;El bal&oacute;n sali&oacute; a las nubes!" fueron de las m&aacute;s ben&eacute;volas con el &aacute;nimo de denigrar y desprestigiar a jugador y t&eacute;cnico.</p>
<p><img src="https://l10preunestawamb.blob.core.windows.net/lpa/images/legacy/201506/662x372a_05155301148.jpg" alt="" /></p>
<p><em>El excelente marcador amarillo, Paco Castellano, posando para la c&aacute;mara de Hern&aacute;ndez Gil en los proleg&oacute;menos del encuentro ante el Real Madrid.</em></p>
<p>En un rotativo le&iacute;amos la siguiente cr&oacute;nica: "A la red (Gento) y al limbo (Paco Castellano)".</p>
<p>"&iquest;Qui&eacute;n orden&oacute; a Paco Castellano lanzar el penalti?"</p>
<p>"La verdad es que no lo decimos ahora, despu&eacute;s del acontecimiento, sino que expresamos nuestra extra&ntilde;eza en el momento mismo de ver que efectivamente, era Paco Castellano el que iba a lanzar el castigo, porque nos parec&iacute;a anormal que lo hiciera &eacute;l estando Guedes, Tonono o Gilberto II en el campo, que son jugadores con un magn&iacute;fico toque de bal&oacute;n y dotados de temple y serenidad. Pero no sabemos por qu&eacute; raz&oacute;n, Castellano fue el elegido para ejecutarlo".</p>
<p>La aut&eacute;ntica realidad es que el bal&oacute;n sali&oacute; lamiendo la base del poste derecho de la porter&iacute;a defendida por Betancor. Un disparo fort&iacute;simo que pudo haber entrado pero que se fue fuera por muy poco como se puede apreciar en las im&aacute;genes. La instant&aacute;nea gr&aacute;fica es una realidad insondable que se para en el tiempo para actuar como juez y verificar la aut&eacute;ntica verdad de los hechos.</p>
<p>Como prueba y testimonio de lo aqu&iacute; expuesto, narramos la cr&oacute;nica de la informaci&oacute;n de otro peri&oacute;dico local escrita en t&eacute;rminos que creemos muy rigurosos:</p>
<p>"La desgracia del penalti fallado colmaba la medida de la t&iacute;pica mala suerte ante el Madrid, pero ese penalti indudablemente&nbsp; mucho m&aacute;s severo que el se&ntilde;alado a Las Palmas, result&oacute; absurdo que lo fuera a ejecutar uno de los jugadores de menos t&eacute;cnica y de menos serenidad tambi&eacute;n del equipo. Absurdo, vamos. Porque si en los entrenamientos lo ha venido haciendo bien, no es lo mismo sin p&uacute;blico, sin responsabilidad, que en un partido trascendente. El experimento de Castellano como lanzador de penaltis no ha podido ser, en todo caso, m&aacute;s penoso y desdichado, y tir&oacute; la falta como cab&iacute;a esperar dado su estilo de jugador ausente de calidad. All&iacute;, en el terreno de juego, estaban otros compa&ntilde;eros como Juanito Guedes y Mart&iacute;n, mucho m&aacute;s cualificados para lanzarlo pero, en fin, ya no hay remedio".</p>
<p>Hemos escogido estas narraciones como prueba y testimonio de los comentarios vertidos sobre el penalti ejecutado por el jugador.</p>
<p>Con el transcurrir de los a&ntilde;os la rumorolog&iacute;a ha ido incrementando la noticia, convirti&eacute;ndola en una hip&eacute;rbole desmesurada, causando profundo da&ntilde;o y desprestigio en jugador y t&eacute;cnico. Ya es archisabido el dicho que "una mentira dicha muchas veces llega a convertirse en verdad".</p>
<p>El &uacute;ltimo gol madridista llegar&iacute;a en las postrimer&iacute;as del encuentro en una combinaci&oacute;n entre Gento y Amancio que este &uacute;ltimo aprovechar&iacute;a para marcar.</p>
<p><img src="https://l10preunestawamb.blob.core.windows.net/lpa/images/legacy/201506/662x372a_05155334149.jpg" alt="" /></p>
<p><em>Amancio.</em></p>
<p>En definitiva, un partido que dejar&iacute;a muy mal sabor a tenor de c&oacute;mo se hab&iacute;a desarrollado la primera media hora de juego.</p>
<p>A las &oacute;rdenes del &aacute;rbitro Sr.Tejerina los equipos formaron con las siguientes alineaciones:</p>
<p>UD Las Palmas: Oregui; Hern&aacute;ndez, Tonono, Jos&eacute; Luis; Castellano, Guedes; Le&oacute;n, Mart&iacute;n, (Jos&eacute; Juan), Trona, Gilberto II y Gilberto I.</p>
<p>Real Madrid: Betancor; Calpe, De Felipe, Sanch&iacute;s; Pirri, Zoco; Fleitas, Amancio, Grosso, Vel&aacute;zquez y Gento.</p>
<p>Actuaron como capitanes Tonono y Gento.</p>
<p><strong>La opini&oacute;n en la caseta local.</strong></p>
<p><img src="https://l10preunestawamb.blob.core.windows.net/lpa/images/legacy/201506/662x372a_05155402150.jpg" alt="" /></p>
<p><em>Luis Molowny.</em></p>
<p>"Comenzamos de forma excelente, pudiendo sentenciar el encuentro a nuestro favor. El Real Madrid se vio sorprendido con dos goles espl&eacute;ndidos de Le&oacute;n y Juanito Guedes pero est&aacute; visto que con el Real Madrid no tenemos suerte. El equipo blanco corri&oacute; mucho en la segunda mitad y los encuentros duran noventa minutos. No comprendo la pol&eacute;mica que se ha originado sobre el penalti lanzado por Paco Castellano. En los entrenamientos era el mejor que los ven&iacute;a ejecutando y de ah&iacute; su elecci&oacute;n para tirarlo. Tambi&eacute;n otros jugadores como Juanito Guedes lo han tirado con signo negativo".</p>
<p>&nbsp;</p>
<p><strong>La opini&oacute;n en la caseta visitante:</strong></p>
<p><img src="https://l10preunestawamb.blob.core.windows.net/lpa/images/legacy/201506/662x372a_05155448151.jpg" alt="" /></p>
<p><em>Miguel Mu&ntilde;oz.</em></p>
<p>Creo que los aficionados canarios han presenciado un gran encuentro. En la primera mitad, es justo decirlo, nos sorprendieron con dos goles. En la segunda parte mi consigna fue llevada a cabo a la perfecci&oacute;n por los jugadores. Los encuentros se ganan luchando y corriendo m&aacute;s que el contrario.</p>
<p>Creo que el resultado ha sido justo a tenor del juego desarrollado en los dos tiempos y sobre todo teniendo en cuenta que los puntos han sido conseguidos fuera de casa y ante un gran equipo.</p>
<p><strong>El jugador Paco Castellano rememora la tan comentada pena m&aacute;xima ante el Real Madrid con serena objetividad y la perspectiva del tiempo.</strong></p>
<p>Abordamos a Paco Castellano en un almuerzo que venimos organizando todos los a&ntilde;os exjugadores y exdirectivos. Ambos hemos compartido muchos a&ntilde;os en la UD Las Palmas,&nbsp;&nbsp; grandes alegr&iacute;as, y por qu&eacute; no decirlo, tambi&eacute;n amargos sinsabores, con conversaciones en la entidad, estadios de f&uacute;tbol, viajes, hoteles, tertulias, y debo confesar que dado mi car&aacute;cter retra&iacute;do, por no herir su autoestima, nunca he tenido el valor de mencionarle aquel infortunio del penalti fallado. Una pena m&aacute;xima que en otros equipos o con otros jugadores no hubiese tenido la mayor trascendencia pero que en este caso la rumorolog&iacute;a lo ha convertido en un suceso desdichado de la historia del club, permaneciendo en la memoria viva y colectiva de todos los aficionados.</p>
<p>Por aquellos a&ntilde;os, el autor que suscribe este art&iacute;culo, cumpl&iacute;a el servicio militar en las fuerzas a&eacute;reas cuya base estaba instalada en el Paseo de Chil, a tiro de piedra del Estadio Insular. Me destinaron a la denominada Polic&iacute;a de Calle que ten&iacute;a como una de sus obligaciones acudir a los partidos en el recinto deportivo cuando jugaba nuestro equipo representativo.</p>
<p>Por regla general nos coloc&aacute;bamos al lado de la porter&iacute;a de la Grada de Naciente que fue precisamente donde tuvo lugar la ejecuci&oacute;n de la pena m&aacute;xima. Pude ver a pocos metros la trayectoria del bal&oacute;n que pasar&iacute;a lamiendo el palo derecho de la porter&iacute;a defendida por Betancor y c&oacute;mo el esf&eacute;rico, despu&eacute;s de impactar en una valla met&aacute;lica, volv&iacute;a de nuevo al campo de juego para ser recogido por la propia defensa madridista.</p>
<p>El pundonoroso defensa era reacio a hablar sobre el tema pero ante nuestra insistencia y la evidencia de la instant&aacute;nea gr&aacute;fica de Hern&aacute;ndez Gil, accede finalmente con semblante de nostalgia de una dorada juventud que se nos va para no volver.</p>
<p>En un principio le costaba hilvanar la narraci&oacute;n de los hechos, para tras una larga pausa exclamar: " &iexcl;Me resulta tan hiriente hablar de este tema!"</p>
<p><em>&nbsp;</em></p>
<p><img src="https://l10preunestawamb.blob.core.windows.net/lpa/images/legacy/201506/662x372a_05155551152.jpg" alt="" /></p>
<p><em>Paco Castellano en la actualidad.</em></p>
<p><em>&nbsp;"Es un debate que me cansa y me ha hecho mucho da&ntilde;o a los largo de los a&ntilde;os. Con humildad he de decir que soy el jugador canario de la UD Las Palmas con m&aacute;s partidos en Primera Divisi&oacute;n en toda la historia del club y creo haber conseguido muchos logros importantes junto a mis compa&ntilde;eros. Era un equipo que jugaba de memoria. Por primera vez en la historia del club se pudo golear a equipos tan poderosos como el Barcelona, Atl&eacute;tico de Madrid o Espa&ntilde;ol. Las gradas del Insular estaban a rebosar en cada encuentro y la afici&oacute;n gozaba como si se tratara de una aut&eacute;ntica fiesta. Resulta inadmisible que de tantas alegr&iacute;as y triunfos que tuvimos en aquella &eacute;poca dorada del club, despu&eacute;s de aquel fat&iacute;dico partido, me saquen a colaci&oacute;n solamente el penalti ante el Real Madrid.</em></p>
<p><em>Me duele por varias razones: en primer lugar, hemos visto en reiteradas ocasiones c&oacute;mo los mejores jugadores del mundo en todas las &eacute;pocas han fallado penaltis, algunos de forma consecutiva y a mayor distancia y nadie ha hecho el m&aacute;s m&iacute;nimo comentario, s&oacute;lo se hace referencia al m&iacute;o y de forma irrespetuosa, hiriente y sesgada. Lo que argumentas en tu art&iacute;culo sobre la famosa frase "una mentira dicha muchas veces se convierte en verdad" es una pura realidad. Por otra parte no s&oacute;lo implica el fallar un penalti sino los comentarios err&oacute;neos y desproporcionados que se han vertido por "profesionales" sobre la trayectoria del bal&oacute;n.</em></p>
<p><em>El caso es muy simple de contar y te agradezco mucho que me hayas proporcionado esta foto ya que una imagen vale m&aacute;s que mil palabras y todo lo que yo pueda decir.</em></p>
<p><em>La semana anterior a aquel encuentro hab&iacute;amos jugado en el nuevo estadio de Manzanares ante el Atl&eacute;tico de Madrid, saliendo vencedores y aup&aacute;ndonos en el primer lugar de la clasificaci&oacute;n, invictos, al haber goleado al Elche en el primer partido de liga. Sin embargo, en el encuentro ante el club colchonero, el defensa Iglesias no dej&oacute; de emplear toda clase de brusquedades con Germ&aacute;n al que inflam&oacute; un ojo de forma considerable. En una de tantas entradas alevosas, Germ&aacute;n repeli&oacute; la agresi&oacute;n y fue expulsado del terreno de juego. Como consecuencia de dicha expulsi&oacute;n, a mi entender la &uacute;nica en su carrera deportiva, Germ&aacute;n, que era el especialista en tirar&nbsp; desde el punto de once metros, no pudo jugar ante el Real Madrid.</em></p>
<p><em>Nuestro entrenador, Luis Molowny, se esmer&oacute; m&aacute;s que nunca en practicar los penaltis, siendo yo el que mejores guarismos ten&iacute;a. Todo ello lo saben mis compa&ntilde;eros que practicaron conmigo toda la semana. En el equipo hab&iacute;a jugadores como Guedes, Mart&iacute;n II o Gilberto II que tambi&eacute;n pod&iacute;an haber sido los elegidos pero ellos, al ser m&aacute;s t&eacute;cnicos, trataban de colocar el bal&oacute;n y fallaban m&aacute;s que yo porque los porteros que ten&iacute;amos en la plantilla como Oregui, Ulacia o Catal&aacute; le adivinaban en ocasiones sus intenciones. Yo, por el contrario, tiraba a romper y el bal&oacute;n iba con tanta fuerza que no ten&iacute;an tiempo de pensar y detenerlo.</em></p>
<p><em>El entrenador, Luis Molowny, me llam&oacute; aparte y, mir&aacute;ndome fijamente, me dijo: "Si hay alguna pena m&aacute;xima, usted es el jugador elegido para tirarla". Era un hombre reservado y de pocas palabras. Yo le confirm&eacute; que los ensayos en los entrenamientos me hab&iacute;an dado mucha confianza y que no ten&iacute;a ning&uacute;n problema en ejecutarlos.</em></p>
<p><em>Cuando el &aacute;rbitro se dirigi&oacute; al punto de penalti no dud&eacute; lo m&aacute;s m&iacute;nimo en coger el bal&oacute;n y mis compa&ntilde;eros, lejos de hacer alg&uacute;n adem&aacute;n para quit&aacute;rmelo, me animaban y ped&iacute;an que lo lanzara.</em></p>
<p><em>No tengo ninguna excusa por haberlo fallado pero todos los que conocieron el Estadio Insular saben que en el &aacute;rea peque&ntilde;a el c&eacute;sped se mezclaba con la tierra y las ra&iacute;ces, hab&iacute;a muchos desniveles. Influyen muchos condicionantes a la hora de tirar un penalti. El factor suerte, el estado del terreno, las prisas del &aacute;rbitro, la trascendencia del encuentro y del marcador, y tambi&eacute;n Betancor, que era un especialista en detener penaltis y cubr&iacute;a mucha puerta.</em></p>
<p><em>Fui con gran seguridad al bal&oacute;n y tir&eacute; con toda mi fuerza. Con la potencia que iba el esf&eacute;rico, de entrar entre los tres palos, Betancor habr&iacute;a tenido muchas dificultades en detenerlo pero algo debi&oacute; fallar, posiblemente la colocaci&oacute;n del bal&oacute;n en el punto de penalti, ya que &eacute;ste sali&oacute; a media altura lamiendo el poste derecho, como se puede apreciar en la instant&aacute;nea de Hern&aacute;ndez Gil.</em></p>
<p><img src="https://l10preunestawamb.blob.core.windows.net/lpa/images/legacy/201506/662x372a_05155632153.jpg" alt="" /></p>
<p><strong><em>Una imagen vale m&aacute;s que mil palabras. </em></strong></p>
<p><em>En la instant&aacute;nea se observa perfectamente c&oacute;mo el bal&oacute;n lanzado desde el punto de penalti por el jugador amarillo, Paco Castellano, sale lamiendo el poste, a media altura,&nbsp; ante la atenta mirada del portero madridista Antonio Betancor.</em></p>
<p>&nbsp;</p>
<p><em>En ese momento pod&iacute;amos haber empatado un encuentro que llegamos a ir ganando por dos tantos de ventaja y al ver que el grader&iacute;o enmudec&iacute;a cre&iacute; morirme.</em></p>
<p><img src="https://l10preunestawamb.blob.core.windows.net/lpa/images/legacy/201506/662x372a_05155713154.jpg" alt="" /></p>
<p><em>Imagen de Castellano en la d&eacute;cada de los setenta.</em></p>
<p><em>A partir de ese fat&iacute;dico d&iacute;a la prensa comenz&oacute; a decir que el bal&oacute;n hab&iacute;a traspasado la Grada de Fedora y hab&iacute;a ido a las nubes creando opini&oacute;n entre los aficionados que cada vez incrementaban m&aacute;s la distancia</em></p>
<p><em>Pero si las cr&iacute;ticas me hac&iacute;an da&ntilde;o y bajaban mi autoestima, m&aacute;s me dol&iacute;an los comentarios vertidos sobre Luis Molowny cuando argumentaban que me hab&iacute;a elegido con la intenci&oacute;n premeditada de fallar, dado su pasado y vinculaci&oacute;n madridista. Todos los que conocimos a Luis Molowny sabemos de su honradez y honestidad. Era todo un ejemplo de integridad moral y profesionalidad y por todos estos valores le ten&iacute;amos un profundo afecto y respeto, &iexcl;era como un padre para los jugadores y el mejor entrenador que he tenido en mi dilatada trayectoria deportiva!".</em></p>
<p>&nbsp;</p>
<p><img src="https://l10preunestawamb.blob.core.windows.net/lpa/images/legacy/201506/662x372a_05155742156.jpg" alt="" /></p>
<p><em>El jugador Paco Castellano salta al campo del Estadio Insular portando un ramo de flores el d&iacute;a de su despedida como futbolista.</em></p>
<p><img src="https://l10preunestawamb.blob.core.windows.net/lpa/images/legacy/201506/662x372a_05155821155.jpg" alt="" /></p>
<p><em>Paco Castellano se despide de la afici&oacute;n en un encuentro amistoso de pretemporada ante la Real Sociedad. En la imagen, en compa&ntilde;&iacute;a de sus hijos: Marta, Mar&iacute;a Jos&eacute;, Magdalena y Pachi.</em></p>
<p><img src="https://l10preunestawamb.blob.core.windows.net/lpa/images/legacy/201506/662x372a_05155847158.jpg" alt="" /></p>
<p><em>Los jugadores de la UD Las Palmas alzan a hombros a Paco Castellano al retirarse del campo en su partido de homenaje ante una prolongada ovaci&oacute;n.</em></p>
<p><img src="https://l10preunestawamb.blob.core.windows.net/lpa/images/legacy/201506/662x372a_05155923157.jpg" alt="" /></p>
<p><em>En&nbsp; la imagen, el jugador Paco Castellano dirige unas sentidas palabras de agradecimiento a todos los comensales el d&iacute;a de su homenaje. Le acompa&ntilde;an el presidente del club, D. Atilio Ley Duarte y su bella esposa Berta, quien no puede contener la emoci&oacute;n.</em></p>
<p><img src="https://l10preunestawamb.blob.core.windows.net/lpa/images/legacy/201506/662x372a_05160001159.jpg" alt="" /></p>
<p><em>El jugador Paco Castellano ha sido siempre un muchacho sencillo de cortas palabras y de l&aacute;grima f&aacute;cil.</em></p>
<p><em>Sus compa&ntilde;eros de equipo, conocedores de su sensibilidad, se proponen hacerlo llorar hasta conseguirlo sin grandes dificultades. </em></p>
<p><em>A su lado, su inseparable esposa Berta sonr&iacute;e complacida.</em></p>
<p>&nbsp;</p>
<p><strong>En Berl&iacute;n, en el partido de vuelta de la Copa de Ferias se daba por descontado la victoria del Hertha.</strong></p>
<p>El corresponsal en Alemania del diario "As", Eduardo Prado, publicaba una amplia informaci&oacute;n sobre el match:</p>
<p><strong>&iexcl;ATENCI&Oacute;N LAS PALMAS!</strong></p>
<p><strong>EN BERL&Iacute;N SE DA POR DESCONTADA LA VICTORIA DEL HERTHA SOBRE LOS CANARIOS EL PR&Oacute;XIMO D&Iacute;A PRIMERO DE OCTUBRE.</strong></p>
<p><strong>EL DIARIO "BERLINER MORGENPOST" EXPONE: "EL HERTHA TIENE LA SART&Eacute;N POR EL MANGO Y DEBE SEGUIR EN LA COMPETICI&Oacute;N".</strong></p>
<p>Mal se le han puesto las cosas al Las Palmas con ese empate a cero registrado en el primer partido de la competici&oacute;n europea Copa Ciudades de Feria. Este primer contacto del equipo canario en torneos europeos, que es, pr&aacute;cticamente, como un bautismo para los disc&iacute;pulos de Luis Molowny, no ha podido tener un signo m&aacute;s adverso para los de las Islas Afortunadas, pues si bien ese empate sin goles no debe considerarse como una derrota, las posibilidades de obtener un resultado positivo el pr&oacute;ximo d&iacute;a 1 de octubre frente al Hertha BSC Berl&iacute;n en el Estadio Ol&iacute;mpico, son realmente muy escasas. Adem&aacute;s, Las Palmas no podr&aacute; contar con el concurso de Guedes, expulsado en el minuto veintid&oacute;s del encuentro por agredir con la cabeza al interior izquierdo berlin&eacute;s Wolfgang Gayer. Es cierto que un empate a uno o m&aacute;s goles bastar&iacute;a para que el conjunto canario se clasificara para la siguiente ronda, pero tampoco conviene olvidar que un triunfo m&iacute;nimo de los berlineses supondr&iacute;a la eliminaci&oacute;n del cuadro canario.</p>
<p><img src="https://l10preunestawamb.blob.core.windows.net/lpa/images/legacy/201506/662x372a_05160045160.jpg" alt="" /></p>
<p><em>Estadio Ol&iacute;mpico de Berl&iacute;n</em>.</p>
<p>Tanto la afici&oacute;n de Berl&iacute;n como la prensa deportiva de la antigua capital alemana se muestran muy optimistas con miras al encuentro de vuelta. En este sentido se manifiestan, poco m&aacute;s o menos, todos los peri&oacute;dicos de Berl&iacute;n. As&iacute;, "Der Tagesspiegel" recoge las impresiones del entrenador del Hertha, Helmut Kronsbein: "Si un equipo como el m&iacute;o ofrece el 1 de octubre, en el Estadio Ol&iacute;mpico, una actuaci&oacute;n tan completa como la del primer encuentro en el Estadio Insular de Las Palmas, entonces no me queda la menor duda de que el Hertha continuar&aacute; adelante en la competici&oacute;n Copa Ciudades de Feria". El diario berlin&eacute;s cita lo que a continuaci&oacute;n traducimos para nuestros lectores: "Este 0-0 se consum&oacute; gracias a la extraordinaria labor del portero Gernot Fraydl y del defensa Enders, que fueron los jugadores m&aacute;s sobresalientes del Hertha. La delantera, por el contrario, desperdici&oacute; inmejorables ocasiones de marcar, de manera especial Horr, Gayer y Steffenhagen. La ocasi&oacute;n m&aacute;s clara la tuvo Arno Steffenhagen a trece minutos del final. En su af&aacute;n de salvar la salida del portero espa&ntilde;ol Oregui, no pudo materializar el tanto. No debe omitirse que este empate fue obtenido contra diez jugadores espa&ntilde;oles, ya que mediado el primer tiempo, el &aacute;rbitro portugu&eacute;s, Rosa D&iacute;az, decret&oacute; la expulsi&oacute;n de Guedes por agredir intencionadamente a Gayer. El imparcial trencilla lusitano no concedi&oacute; posteriormente, un penalti al conjunto de Las Palmas, por estimar que el bal&oacute;n fue a dar involuntariamente al brazo de Uwe Witt. Esta decisi&oacute;n arbitral fue ruidosamente protestada por los 25.000 espectadores que presenciaron el partido. Despu&eacute;s del descanso, el entrenador berlin&eacute;s, Kronsbein, sustituy&oacute; a Altendorff por Bredenfeld".</p>
<p><img src="https://l10preunestawamb.blob.core.windows.net/lpa/images/legacy/201506/662x372a_05160124161.jpg" alt="" /></p>
<p><em>Helmut&nbsp; Kronsbein.</em></p>
<p>Por su parte el "Berliner Morgenpost" se expresa en los siguientes t&eacute;rminos:"El Hertha BSC tiene la sart&eacute;n por el mango y no debe desperdiciar la ocasi&oacute;n de clasificarse para la siguiente ronda. Las Palmas, despu&eacute;s de sus sensacionales triunfos frente al Elche por 5-1 y por 2-1 contra el Atl&eacute;tico de Madrid en el estadio madrile&ntilde;o del Manzanares, no ser&aacute; un rival f&aacute;cil. En el partido de ida, los subcampeones de Espa&ntilde;a no fueron capaces de hacer tan siquiera un gol contra los berlineses, que se defendieron con u&ntilde;as y dientes. El Hertha desaprovech&oacute; en este partido dos claras oportunidades de gol".</p>
<p><strong>"EL EMPATE EN LAS PALMAS ES COMO UNA VICTORIA"</strong></p>
<p>Un tercer diario berlin&eacute;s, el "Telegraf", resume su impresi&oacute;n para el encuentro de vuelta de la forma siguiente: "El empate a cero en Las palmas es como una victoria. Casi un triunfo en toda la l&iacute;nea". El rotativo berlin&eacute;s subraya las palabras del presidente del Hertha: "Estoy gratamente sorprendido". El se&ntilde;or Gerhard Bautz a&ntilde;ade: "En la devoluci&oacute;n de visita, el pr&oacute;ximo 1 de octubre, el Estadio Ol&iacute;mpico se llenar&aacute; hasta la bandera".</p>
<p>Este es el ambiente que reina en Berl&iacute;n. Ni los m&aacute;s pesimistas dudan que el Hertha eliminar&aacute; a la Uni&oacute;n Deportiva Las Palmas. Hay confianza y se espera derrotar al cuadro canario. Todas las bazas est&aacute;n a favor de los berlineses, pero un partido de f&uacute;tbol hay que jugarlo en sus noventa minutos, y qui&eacute;n nos dice que no ser&aacute;n los subcampeones espa&ntilde;oles los que se lleven el gato al agua. El d&iacute;a 1 de octubre, la soluci&oacute;n, con el permiso, claro est&aacute;, del Hertha BSC Berl&iacute;n.</p>
<p align="right"><strong>Informa Eduardo Prado, corresponsal de As en Alemania.</strong></p>
<p>&nbsp;</p>
<p>&nbsp;</p>
<p>&nbsp;</p>
<p>El diario "Marca", a su vez, publicaba:</p>
<p><strong>El Hertha de Berl&iacute;n, muy alem&aacute;n en su t&eacute;cnica y condici&oacute;n f&iacute;sica.</strong></p>
<p><strong>As&iacute; es el rival de la UD Las Palmas en la Copa de Ferias.</strong></p>
<p><strong>Puede ser peligrosos si las figuras del a&ntilde;o pasado y las nuevas llegan a entenderse.</strong></p>
<p>&nbsp;</p>
<p>En estos&nbsp; meses puente entre la temporada futbol&iacute;stica que en junio termin&oacute; y la que en el pr&oacute;ximo agosto se iniciar&aacute;, el Hertha de Berliner Sport Club ha vuelto a dar que hablar. Del Hertha de Berl&iacute;n puede decirse que con &eacute;l siempre va el esc&aacute;ndalo. Hace unos a&ntilde;os &ndash;cuando por vez primera consigui&oacute; ser incluido en la Bundesliga- , por las adquisiciones que hizo, gastando exorbitantes cantidades de dinero (aunque nunca se supo cu&aacute;nto); despu&eacute;s, por ser condenado por la Federaci&oacute;n Alemana al descenso, al no haberse mantenido dentro del cap&iacute;tulo econ&oacute;mico que, en cuesti&oacute;n fichajes, tiene especificado la Federaci&oacute;n; posteriormente, por proclamarse campe&oacute;n sin derecho al ascenso y armar la marimorena en la revisi&oacute;n de su famoso "affaire". Ahora, porque, en este verano, ha sido quien m&aacute;s numerosas &ndash;y valiosas- adquisiciones hizo, hasta convertirse de nuevo en "el coco" del mercado futbol&iacute;stico alem&aacute;n. Del Hertha, pues, es necesario hablar, en este caso de mi reportaje, por aquello que es rival, Copa de Europa de Ferias por medio, de las huestes de Luis Molowny.</p>
<p><strong>UN EQUIPO CON HISTORIA.</strong></p>
<p>A m&iacute; me gusta empezar las cosas por su justo principio. Debo mecanografiar, pues, que el Hertha es todo un veterano del f&uacute;tbol alem&aacute;n, ya que naci&oacute; nada menos que en 1892, concretamente el d&iacute;a de Santiago Ap&oacute;stol. Los colores del Hertha son azul y blanco, utilizando indistintamente una el&aacute;stica al estilo del Espa&ntilde;ol barcelon&eacute;s, o toda azul, o toda blanca con escapulario azul, aparte calzones blancos. Ya me parece haberles contado a ustedes en una oportunidad que el terreno de juego del club, el Herthasportplatz, est&aacute; muy pr&oacute;ximo a la estaci&oacute;n ferroviaria de Gesundbrunnen, justo en la divisoria con el otro Berl&iacute;n, por lo que los balones que salen disparados a la zona de protecci&oacute;n sovi&eacute;tica los llaman los del Hertha "comunistas", si no regresan, o "esp&iacute;as", si son devueltos por los berlineses del otro lado. Este terreno deportivo tiene una capacidad para 22.000 espectadores. Pero el Hertha, cuando est&aacute; en la Bundesliga o de partidos internacionales se trata, se enfrenta a sus rivales sobre el c&eacute;sped del veterano Estadio Ol&iacute;mpico, que ya se sabe tiene una capacidad para nada menos que 94.000 espectadores, 61.000 de ellos con derecho a asiento. En el Estadio Ol&iacute;mpico no hay localidades bajo techado.</p>
<p>El rival de la UD Las palmas en la Copa de Ferias, cuenta con cerca de dos millares de socios&nbsp; -en Alemania, los clubs de f&uacute;tbol no tienen nunca demasiados socios-, pero es, con mucho, la entidad futbol&iacute;stica que mejores taquillas hace cada temporada que juega en la Bundesliga. Su promedio de espectadores rebasa, con mucho, el de los clubs que m&aacute;s &eacute;xito de p&uacute;blico puedan tener en la Rep&uacute;blica Federal. Pero esto es ya de hoy, y yo quer&iacute;a hablar del Hertha de muchos a&ntilde;os atr&aacute;s. De ese Hertha hay que se&ntilde;alar que, antes de la Segunda Guerra Mundial, gan&oacute; la Liga de Brandenburgo &ndash; lo que equivale a decir que jug&oacute; la fase final del Campeonato Nacional de Alemania-, en los a&ntilde;os 1906, 1915, 1917, 1918, 1925 al 1931 y 1933. Que, desde la divisi&oacute;n de Alemania ha logrado el t&iacute;tulo de Berl&iacute;n, equivalente al Brandenburgo de antes, en los a&ntilde;os 1957, 1961 y 1963. Este &uacute;ltimo es el de la fundaci&oacute;n de la Bundesliga, en la que el Hertha fue incluido. Bien, hay que se&ntilde;alar igualmente que, en 1930 y 1931 consigui&oacute; proclamarse campe&oacute;n nacional absoluto. No cabe duda, pues, de que se trata de un equipo con historia.</p>
<p><strong>EL &Uacute;LTIMO CICLO: 1963-1969</strong></p>
<p>Ya est&aacute; explicado que el m&aacute;s famoso equipo de Berl&iacute;n fue incluido en la Bundesliga al fundarse &eacute;sta y que por tanto, en la temporada 1963-64 particip&oacute; en la competici&oacute;n que cada a&ntilde;o re&uacute;ne a los mejores equipos del pa&iacute;s, diecis&eacute;is en las dos primeras ediciones, dieciocho a partir de la tercera. El Hertha tuvo una discret&iacute;sima actuaci&oacute;n en las temporadas de 1963-64 y 1964-65, quedando en ambas clasificado en decimocuarta posici&oacute;n, con un punto m&aacute;s en cada oportunidad que el vicecolista y compa&ntilde;ero de desventuras &ndash;descenso- del linterna roja de la clasificaci&oacute;n.</p>
<p>Quienes reg&iacute;an al Hertha pensaron que lo mejor de todo ser&iacute;a echar la casa por la ventana, adquirir elementos de la m&aacute;xima categor&iacute;a y ofrecer as&iacute; al p&uacute;blico de Berl&iacute;n lo que seguramente Berl&iacute;n se merece. Dicho y hecho&hellip;, pero, atenerse a las consecuencias, nada m&aacute;s terminar aquel loco verano de los fichajes famosos. Los dem&aacute;s clubs se sintieron molestos con tan fabulosa competencia, hubo alguien que no fue todo lo discreto que hab&iacute;a que ser y se produjo el tirar de la manta y que el "affaire" Hertha quedase al descubierto. Es decir, que la DFB (Federaci&oacute;n) qued&oacute; enterada de los tremendos dispendios de los berlineses, con cifras que rebasaban (&iexcl;Y cu&aacute;nto!) los topes puestos por la Federaci&oacute;n en materia de fichajes. As&iacute; que el Hertha fue juzgado y condenado. El veredicto, descenso a la Liga Regional y prohibici&oacute;n de ascender a la Bundesliga en tres a&ntilde;os, por muy campe&oacute;n regional que consiguiera ser.</p>
<p>El plazo final de la condena en cuesti&oacute;n finalizaba con la temporada 1967-1968, a cuyo final, los albiazules berlineses ganan en el terreno de juego otra vez, pero ahora en forma permitida, el ascenso a la Bundesliga. Reforzaron su equipo modestamente, pero con adquisiciones tan notables como Fraydl, Ipta y Brungs, los que, en el ejercicio pasado ayudaron lo suyo al que el equipo consiguiera la permanencia, logrando de nuevo el decimocuarto puesto de la tabla; pero ahora, como son dieciocho los que compiten, dejando a cuatro tras &eacute;l. Hay que decir, en todo caso, que el terrible invierno que padecieron los berlineses hizo que se tuvieran que suspender numerosos partidos de liga, lo que rompi&oacute; el ritmo del equipo cuando &eacute;ste marchaba entre los cinco primeros de la liga. Pero el final fue dichoso.</p>
<p><strong>El equipo 1969-70</strong></p>
<p>Repito que, en estos meses puente que entre la pasada y la pr&oacute;xima temporada estamos viviendo, el Hertha ha conseguido poner nerviosos a los dem&aacute;s equipos alemanes, puesto que ha sido el que m&aacute;s cantidad de jugadores ha adquirido, el que m&aacute;s dinero ha pagado y quien mejores valores ha llevado a sus filas. Est&aacute; por ver, solamente, si luego las nueces ser&aacute;n de verdad tantas como el ruido que han armado. De la media docena de jugadores nuevos en la plantilla hay cuatro de aut&eacute;ntica categor&iacute;a, como son Patzke, Horr, Gayer y Varga.</p>
<p>El primero de ellos, Bernd Patzke, es el de m&aacute;s categor&iacute;a. Defensa lateral, que juega indistintamente a la derecha y la izquierda, procede del M&uuml;nchen 1860 y cumpli&oacute; en marzo pasado veintis&eacute;is a&ntilde;os. En la pasada temporada, de los diez partidos que la selecci&oacute;n alemana jug&oacute;, Patzke estuvo presente en ocho en las filas del equipo nacional, lo que equivale a decir que ha sido internacional en diecisiete oportunidades. Es un zaguero muy h&aacute;bil, de excelente t&eacute;cnica y con la cl&aacute;sica dureza germana.</p>
<p>Lorenzo Horr es un joven delantero centro que ha sido, quiz&aacute;, la pieza m&aacute;s deseada de atrapar en las redes de los pescadores de futbolistas. Ariete del Alsenborn &ndash;club regional o de la Segunda Divisi&oacute;n, por decirlo as&iacute;- , ya en la temporada pasada se mostr&oacute; eficaz goleador, y en &eacute;sta ha marcado numeros&iacute;simos goles, tanto en la Liga Regional como en la fase de ascenso. Tiene aut&eacute;ntico olfato para el gol y se le considera un sucesor de Uwe Seler y del muniqu&eacute;s Gerd M&uuml;ller, reyes del gol de ayer y de hoy en este pa&iacute;s.</p>
<p><img src="https://l10preunestawamb.blob.core.windows.net/lpa/images/legacy/201506/662x372a_05160226162.jpg" alt="" /></p>
<p><em>Horr.</em></p>
<p>En cuanto a Gayer y Varga, se trata de dos extranjeros, austriaco el primero &ndash;interior- y procedente del Spotklub de Viena, y h&uacute;ngaro, y tambi&eacute;n delantero, el segundo. Vienen precedidos de mucha fama, en cuanto a su t&eacute;cnica, muy de acorde con el f&uacute;tbol de que proceden. Sucede s&oacute;lo que el asunto Varga est&aacute; en manos de la FIFA porque se trata de un futbolista que prefiri&oacute; "escoger la libertad". Si ser&aacute; autorizado o no a que juegue en Alemania, es cosa que a&uacute;n est&aacute; por ver.</p>
<p><img src="https://l10preunestawamb.blob.core.windows.net/lpa/images/legacy/201506/662x372a_05160251163.jpg" alt="" /></p>
<p><em>Gayer.</em></p>
<p>Bien, pues a &eacute;stos, hay que agregar algunos m&aacute;s, como Gernot Fraydl, Herman Bredenfeld y Franz Brungs, que son futbolistas de gran calidad, y ya est&aacute;n en el Hertha desde la temporada anterior. El rubio Fraydl fue cancerbero del seleccionado austriaco en no menos de treinta oportunidades, dos de ellas en la temporada anterior, todav&iacute;a. Bredenfeld es un joven valor de la "nueva ola", que viene jugando muy bien en su puesto de volante de ataque. Y Franz Brungs fue, tanto en el Nuremberg, como antes en el Borussia de Dortmund y ya esta pasada temporada en el mismo Hertha, uno de los hombres que m&aacute;s goles cosecha en cada temporada. Juega de centro delantero, emplea con fortuna ambas piernas, remata excelentemente de cabeza y, especialmente, tiene una asombrosa movilidad. Sus penetraciones por la derecha y la izquierda, a la antigua usanza, de los antiguos extremos aut&eacute;nticamente extremos, suelen dar m&aacute;s de un disgusto a las coberturas contrarias.</p>
<p>Si las figuras del a&ntilde;o pasado y las figuras de esta nueva temporada llegan a entenderse, no cabe duda que el Hertha puede ser un peligroso rival para cualquier equipo. Esto, en todo caso, est&aacute; por ver. Pero tambi&eacute;n, el Hertha es un equipo correoso y luchador, muy alem&aacute;n en su t&eacute;cnica y condici&oacute;n f&iacute;sica. Normalmente, la UD Las Palmas deber&iacute;a eliminarlo. Pero los nuevos fichajes, seguramente, le dar&aacute;n una potencia que no tuvo en las temporadas precedentes. Ojo, pues, al Hertha Berliner Sport Club.</p>
<p align="right"><strong>CARLOS BRIBIAN</strong></p>
<p>&nbsp;</p>
<p>&nbsp;</p>
<p><strong>Guedes, sancionado, no podr&aacute; jugar ante el Hertha de Berl&iacute;n.</strong></p>
<p>Un lunes 29 de septiembre partir&iacute;a la expedici&oacute;n canaria hacia Berl&iacute;n. Los jugadores que se desplazar&iacute;an ser&iacute;an los siguientes:</p>
<p>Oregui, Catal&aacute;, Hern&aacute;ndez, Mart&iacute;n, Tonono, Jos&eacute; Luis, Menchu, Castellano, Niz, Le&oacute;n, Justo Gilberto, Lemes, Jos&eacute; Juan, Germ&aacute;n, Gilberto I y Trona.</p>
<p>El comit&eacute; de competici&oacute;n de la Copa de Ciudades de Ferias hab&iacute;a sancionado al jugador Juanito Guedes con un partido, sin embargo se incorporaba Lemes ya que en la Copa de Ferias se admite la cifra de cinco suplentes.</p>
<p><img src="https://l10preunestawamb.blob.core.windows.net/lpa/images/legacy/201506/662x372a_05160330164.jpg" alt="" /></p>
<p><em>El masajista Pepe Gonz&aacute;lez y el entrenador Luis Molowny pasean por los jardines del Hotel Santa Br&iacute;gida un d&iacute;a antes de partir hacia Berl&iacute;n.</em></p>
<p><img src="https://l10preunestawamb.blob.core.windows.net/lpa/images/legacy/201506/662x372a_05160406165.jpg" alt="" /></p>
<p><em>El adjunto a la secretar&iacute;a general y jefe de archivos del club, D. Jos&eacute; Guerra P&eacute;rez, trabaj&oacute; incansablemente en la planificaci&oacute;n del viaje a Berl&iacute;n.</em></p>
<p>Acompa&ntilde;aba a la expedici&oacute;n, como siempre, el masajista Jos&eacute; Gonz&aacute;lez, el Secretario General, D. Jes&uacute;s Garc&iacute;a Panasco y, como m&aacute;ximo exponente de la expedici&oacute;n, el vicepresidente del club. D. Atilio Ley Duarte.</p>
<p><img src="https://l10preunestawamb.blob.core.windows.net/lpa/images/legacy/201506/662x372a_05160434167.jpg" alt="" /></p>
<p><em>D. Jes&uacute;s Garc&iacute;a Panasco.</em></p>
<p>&nbsp;</p>
<p><img src="https://l10preunestawamb.blob.core.windows.net/lpa/images/legacy/201506/662x372a_05160502168.jpg" alt="" /></p>
<p><em>C&aacute;lculo en borrador a mano del desplazamiento a Berl&iacute;n efectuado por Jes&uacute;s Garc&iacute;a Panasco.</em></p>
<p><img src="https://l10preunestawamb.blob.core.windows.net/lpa/images/legacy/201506/662x372a_05160544169.jpg" alt="" /></p>
<p><em>Comunicado de la UD las Palmas de su llegada a Berl&iacute;n.</em></p>
<p><img src="https://l10preunestawamb.blob.core.windows.net/lpa/images/legacy/201506/662x372a_05160612170.jpg" alt="" /></p>
<p><em>Relaci&oacute;n de la expedici&oacute;n de la UD las Palmas a la compa&ntilde;&iacute;a de seguros Mare Nostrum.</em></p>
<p><img src="https://l10preunestawamb.blob.core.windows.net/lpa/images/legacy/201506/662x372a_05161235171.jpg" alt="" /></p>
<p><em>Nota de la UD las Palmas a la compa&ntilde;&iacute;a Iberia comunic&aacute;ndole la relaci&oacute;n de pasajeros en su desplazamiento a Berl&iacute;n. Como se puede apreciar en la nota, se adhieren a la lista los periodistas Antonio Lemus Del Moral y Luis Garc&iacute;a Jim&eacute;nez.</em></p>
<p><img src="https://l10preunestawamb.blob.core.windows.net/lpa/images/legacy/201506/662x372a_05161335172.jpg" alt="" /></p>
<p><em>Nota del Secretario General, D. Jes&uacute;s Garc&iacute;a Panasco, a los jugadores de la UD Las Palmas d&aacute;ndoles instrucciones sobre las normas a seguir y la vestimenta adecuada antes de emprender el viaje a Alemania. </em></p>
<p><img src="https://l10preunestawamb.blob.core.windows.net/lpa/images/legacy/201506/662x372a_05161403173.jpg" alt="" /></p>
<p><em>Confirmaci&oacute;n de la llegada del vuelo 694 Panam&eacute;rica al Herha de Berl&iacute;n.</em></p>
<p><img src="https://l10preunestawamb.blob.core.windows.net/lpa/images/legacy/201506/662x372a_05161433174.jpg" alt="" /></p>
<p><em>Telegrama de felicitaci&oacute;n del Gerente del Valencia CF, D. Vicente Peris.</em></p>
<p><img src="https://l10preunestawamb.blob.core.windows.net/lpa/images/legacy/201506/662x372a_05161503175.jpg" alt="" /></p>
<p><em>Tarjeta de felicitaci&oacute;n del Hotel Schweizerhoff Berl&iacute;n.</em></p>
<p><em>El escrito reza en los t&eacute;rminos siguientes: "Con los mejores deseos para una encantadora estancia". </em></p>
<p><em>Fdo. Rodolphe W. Schelbert.</em></p>
<p>&nbsp;</p>
<p><img src="https://l10preunestawamb.blob.core.windows.net/lpa/images/legacy/201506/662x372a_05161528176.jpg" alt="" /></p>
<p><em>Tarjeta de D. Jes&uacute;s Garc&iacute;a Panasco en el Hotel Schweizerhoff Berl&iacute;n.</em></p>
<p><img src="https://l10preunestawamb.blob.core.windows.net/lpa/images/legacy/201506/662x372a_05161554177.jpg" alt="" /></p>
<p><em>Nota de la UD Las Palmas comunicando los precios por persona de la estancia en Berl&iacute;n y la llegada del vuelo.</em></p>
<p><img src="https://l10preunestawamb.blob.core.windows.net/lpa/images/legacy/201506/662x372a_05161624178.jpg" alt="" /></p>
<p><em>Carta del Hotel Schweizerhoff Berl&iacute;n a la UD Las Palmas comunic&aacute;ndole los tr&aacute;mites de pago durante su estancia en Alemania.</em></p>
<p><em>La traducci&oacute;n no literal es la siguiente: </em></p>
<p><em>Referencia: Estancia en el Hotel Schweizerhoff Berl&iacute;n, del 29 de septiembre al 2 de octubre.</em></p>
<p><em>Estimados se&ntilde;ores:</em></p>
<p><em>Les agradecer&iacute;amos encontraran la copia adjunta de nuestra carta a Turistcanarias SA, en la cual se puede apreciar que la factura de su estancia no ha sido pagada hasta la fecha.</em></p>
<p><em>Les estar&iacute;amos muy agradecidos si pudieran ayudarnos en lo concerniente a este asunto.</em></p>
<p><em>Fdo. Rodolphe W. Schelbert.</em></p>
<p>&nbsp;</p>
<p><img src="https://l10preunestawamb.blob.core.windows.net/lpa/images/legacy/201506/662x372a_05161729179.jpg" alt="" /></p>
<p><em>Carta del Secretario General, D. Jes&uacute;s Garc&iacute;a Panasco, al Sr. Pierre Joris, Secretario&nbsp; del Comit&eacute; de la Copa de Ferias,&nbsp; en relaci&oacute;n al malentendido en el pago del encuentro.</em></p>
<p>&nbsp;</p>
<p><img src="https://l10preunestawamb.blob.core.windows.net/lpa/images/legacy/201506/662x372a_05161800180.jpg" alt="" /></p>
<p><em>Carta de D. Jes&uacute;s Garc&iacute;a Panasco al Sr. D. Juan Gich, Delegado Nacional de Educaci&oacute;n F&iacute;sica y Deportes, pidiendo su inestimables ayuda en el caso de la liquidaci&oacute;n del partido celebrado con el Hertha de Berl&iacute;n.</em></p>
<p><img src="https://l10preunestawamb.blob.core.windows.net/lpa/images/legacy/201506/662x372a_05161836181.jpg" alt="" /></p>
<p><em>Acuse de recibo de la carta del Secretario General, D. Jes&uacute;s Garc&iacute;a Panasco, al Sr, D. Juan Gich&nbsp; en lo concerniente a la liquidaci&oacute;n del partido de la Copa de Ferias con el Hertha de Berl&iacute;n.</em></p>
<p>&nbsp;</p>
<p>&nbsp;</p>
<p><img src="https://l10preunestawamb.blob.core.windows.net/lpa/images/legacy/201506/662x372a_05161941182.jpg" alt="" /></p>
<p><img src="https://l10preunestawamb.blob.core.windows.net/lpa/images/legacy/201506/662x372a_05161940183.jpg" alt="" /></p>
<p><em>Carta y certificado enviados por el director del Banco de Canarias, D. Jes&uacute;s G&oacute;mez, a la UD las Palmas inform&aacute;ndo que la orden de pago &nbsp;a Suiza volv&iacute;a a ser denegada.</em></p>
<p><em><img src="https://l10preunestawamb.blob.core.windows.net/lpa/images/legacy/201506/662x372a_05162053184.jpg" alt="" /></em></p>
<p><em>Carta del Secretario General del club a nuestro directivo y miembro de la RFEF en Madrid, D. Pedro Valido Ben&iacute;tez.</em></p>
<p><em>Pese a la solicitud acreditativa del Instituto Espa&ntilde;ol de Moneda y lo que se expone en esta carta con posterioridad, la intervenci&oacute;n del presidente de la RFEF, Sr. Ram&iacute;rez, fue decisiva a la hora de llegar a un acuerdo.</em></p>
<p>&nbsp;</p>
<p><strong>La UD Las Palmas aterriza en Berl&iacute;n.</strong></p>
<p>Calurosa acogida al equipo canario en el aeropuerto de Tempelhof.</p>
<p>La expedici&oacute;n isle&ntilde;a llegaba a Berl&iacute;n a las siete de la tarde. El viaje, como es natural en estos casos, hab&iacute;a sido lento y cansino. Las Palmas-Madrid para proseguir luego en el reactor de la Lufthansa hasta Francfurt y enlazar finalmente con otro avi&oacute;n hasta Berl&iacute;n, que en tiempos pasados fue capital del Reich.</p>
<p><img src="https://l10preunestawamb.blob.core.windows.net/lpa/images/legacy/201506/662x372a_05162129185.jpg" alt="" /></p>
<p><em>La expedici&oacute;n aterriza en el aeropuerto de Frankfurt. En primer plano el masajista Pepe Gonz&aacute;lez, Menchu y Catal&aacute;.</em></p>
<p><img src="https://l10preunestawamb.blob.core.windows.net/lpa/images/legacy/201506/662x372a_05162156186.jpg" alt="" /></p>
<p><em>Pedro Valido Ben&iacute;tez.</em></p>
<p><img src="https://l10preunestawamb.blob.core.windows.net/lpa/images/legacy/201506/662x372a_05162230187.jpg" alt="" /></p>
<p><em>El Gerente del Valencia CF, D. Vicente P&eacute;ris, y el Secretario General de la UD Las Palmas, D. Jes&uacute;s Garc&iacute;a Panasco, se saludan efusivamente.</em></p>
<p>&nbsp;</p>
<p><img src="https://l10preunestawamb.blob.core.windows.net/lpa/images/legacy/201506/662x372a_05162256188.jpg" alt="" /></p>
<p><em>D. Vicente P&eacute;ris.</em></p>
<p>Los jugadores, muy cansados con el largo viaje, tuvieron que soportar los pesados tr&aacute;mites aduaneros, hasta verse al fin libres para subirse al autob&uacute;s que les trasladar&iacute;a al Hotel Schwelzerhof.</p>
<p>Las muestras de j&uacute;bilo al equipo canario fueron innumerables, con muchos seguidores y una bandera espa&ntilde;ola en la balconada central del hotel como homenaje a la expedici&oacute;n isle&ntilde;a.</p>
<p><img src="https://l10preunestawamb.blob.core.windows.net/lpa/images/legacy/201506/662x372a_05162321189.jpg" alt="" /></p>
<p><em>Antonio Lemus Del Moral.</em></p>
<p><img src="https://l10preunestawamb.blob.core.windows.net/lpa/images/legacy/201506/662x372a_05162347190.jpg" alt="" /></p>
<p><em>Luis Garc&iacute;a Jim&eacute;nez.</em></p>
<p>Los del Hertha hab&iacute;an preparado para la delegaci&oacute;n de la UD Las Palmas varios actos en su honor vi&eacute;ndose obligado Luis Molowny a excusar su presencia dado el estricto r&eacute;gimen de concentraci&oacute;n. La cordialidad fue en todo momento magn&iacute;fica.</p>
<p>En la ciudad de Berl&iacute;n el pron&oacute;stico era favorable al equipo de casa, no s&oacute;lo por el resultado del encuentro de ida sino por las sensibles bajas de Juanito Guedes y Mart&iacute;n.</p>
<p>Se preve&iacute;a que&nbsp; aquel mi&eacute;rcoles&nbsp; el Estadio Ol&iacute;mpico registrar&iacute;a un gran lleno.</p>
<p>El campo fue construido por Werner March en 1936 para los XI Juegos Ol&iacute;mpicos y ten&iacute;a en un principio una capacidad de cien mil espectadores, aunque sin tribuna cubierta, siendo totalmente restaurado despu&eacute;s de la Guerra Mundial en que sufri&oacute; considerables da&ntilde;os por parte de los aliados.</p>
<p>La UD Las Palmas entrenar&iacute;a en el Estadio Ol&iacute;mpico con numeroso p&uacute;blico en las gradas y un c&eacute;sped&nbsp; en excelentes condiciones.</p>
<p>La temperatura por la ma&ntilde;ana era de trece grados y sin lluvia, circunstancia que aprovecharon los expedicionarios amarillos para efectuar un recorrido por Berl&iacute;n y sus lugares m&aacute;s visitados, como la Puerta de Brandenburgo, contempl&aacute;ndose las fortificaciones hechas por los orientales para evitar las evasiones de los alemanes comunistas.</p>
<p><img src="https://l10preunestawamb.blob.core.windows.net/lpa/images/legacy/201506/662x372a_05162434191.jpg" alt="" /></p>
<p><em>Como bien afirma el escritor, Antonio Mu&ntilde;oz Molina, "miramos el mundo presente a trav&eacute;s de su propio pasado". En 1969, fecha en que nuestro equipo disputar&iacute;a el partido de vuelta con el Hertha de Berl&iacute;n, hab&iacute;an transcurrido ya ocho a&ntilde;os del levantamiento del Muro de Berl&iacute;n. Se pod&iacute;a a&uacute;n contemplar la frontera de p&uacute;as de alambre y cristales rotos que divid&iacute;a en dos la ciudad y el pa&iacute;s.</em></p>
<p><em>En la imagen, la estructura de esta siniestra construcci&oacute;n que dividi&oacute; Berl&iacute;n y separ&oacute; a sus ciudadanos durante casi veintiocho a&ntilde;os.</em></p>
<p><img src="https://l10preunestawamb.blob.core.windows.net/lpa/images/legacy/201506/662x372a_05162456192.jpg" alt="" /></p>
<p><em>Puerta de Brandenburgo.</em></p>
<p><img src="https://l10preunestawamb.blob.core.windows.net/lpa/images/legacy/201506/662x372a_05162528193.jpg" alt="" /></p>
<p><em>La ciudad de Berl&iacute;n hab&iacute;a sido destruida primero y dividida m&aacute;s tarde en emdio de una Alemania que levantaba un muro para preservar sus inconfesables secretos.</em></p>
<p>Tras un largo paseo con visita al las instalaciones del peri&oacute;dico Bild, llegaban al hotel nuestros jugadores, donde los esperaba una nutrida representaci&oacute;n.</p>
<p>Nuestro equipo no se encontrar&iacute;a solo en el gran Estadio Ol&iacute;mpico ya que se hab&iacute;an registrado m&aacute;s de dos mil peticiones para los trabajadores espa&ntilde;oles residentes en Alemania.</p>
<p>&nbsp;</p>
<p style="text-align: center;"><img src="https://l10preunestawamb.blob.core.windows.net/lpa/images/legacy/201506/662x372a_05162602203.jpg" alt="" />&nbsp;</p>
<p style="text-align: center;">&nbsp;</p>
<p><strong>La UD Las Palmas cae eliminada ante el Hertha de Berl&iacute;n por un penalti inocente de Castellano aunque el colegiado no quiso ver una clar&iacute;sima mano voluntaria en el &aacute;rea berlinesa.</strong></p>
<p><strong>La UD Las Palmas ca&iacute;a injustamente derrotada en el Estadio Ol&iacute;mpico ante el Hertha de Berl&iacute;n.</strong></p>
<p>El partido pudo quedar en empate ya que el &aacute;rbitro checo Sr. Hartmann se&ntilde;alar&iacute;a el m&aacute;ximo castigo a los amarillos pero no quiso ver la clara mano de Witt. En realidad, si bien en la primera mitad su actuaci&oacute;n pas&oacute; desapercibida, en la segunda mitad fue muy parcial y casero, se&ntilde;alando continuadas faltas al marco de Oregui.</p>
<p><img src="https://l10preunestawamb.blob.core.windows.net/lpa/images/legacy/201506/662x372a_05162650194.jpg" alt="" /></p>
<p><em>Witt.</em></p>
<p>En esta ocasi&oacute;n nos ha defraudado el Hertha, muy nervioso, con falta de ligaz&oacute;n en el centro del campo y nula capacidad rematadora. Sin embargo, la UD Las Palmas, que se mostr&oacute; inconmensurable en sus l&iacute;neas de atr&aacute;s, estuvo remisa y torpe en la franja central y sin claridad de ideas en sus hombres punta, a excepci&oacute;n de algunas internadas del extremo Le&oacute;n.</p>
<p>Bien es verdad que la temperatura baj&oacute; muchos enteros a la hora del partido, convirti&eacute;ndose en g&eacute;lida y fr&iacute;a con s&oacute;lo siete grados, aunque ello no justifica el mal encuentro realizado por ambos conjuntos.</p>
<p>Una pena, en definitiva, ya que de haber jugado Mart&iacute;n y Juanito Guedes el resultado hubiera podido ser diferente.</p>
<p>En la primera mitad la defensa canaria estuvo muy segura en todas sus l&iacute;neas, especialmente Hern&aacute;ndez que tuvo una extraordinaria actuaci&oacute;n anulando al extremo izquierdo del equipo rival, Steffenhaguen.</p>
<p><img src="https://l10preunestawamb.blob.core.windows.net/lpa/images/legacy/201506/662x372a_05162716195.jpg" alt="" /></p>
<p><em>Steffenhaguen.</em></p>
<p><img src="https://l10preunestawamb.blob.core.windows.net/lpa/images/legacy/201506/662x372a_05162739196.jpg" alt="" /></p>
<p><em>Niz.</em></p>
<p>En la l&iacute;nea media, Trona, que hab&iacute;a realizado excelentes encuentros como delantero centro, estuvo muy desdibujado sin encontrar nunca su sitio en el terreno de juego, fallando una clar&iacute;sima oportunidad de marcar cuando Germ&aacute;n en un pase centrado lo dej&oacute; solo ante la porter&iacute;a defendida por Wolkman. De igual forma, un tiro fort&iacute;simo de Gilberto I saldr&iacute;a lamiendo el palo. No se puede hablar de m&aacute;s oportunidades claras ya que existi&oacute; una laguna notable en el centro del campo.</p>
<p>El equipo del Hertha nos pareci&oacute; esta vez un conjunto trot&oacute;n, dedic&aacute;ndose a bombear balones sobre el marco de Oregui.</p>
<p>A los nueve minutos de la segunda mitad el tinerfe&ntilde;o Jos&eacute; Juan sustituy&oacute; a Trona para dar m&aacute;s mordiente al ataque sin resultado positivo.</p>
<p>Poco despu&eacute;s llegaba la jugada del penalti, cuando el delantero centro Brungas se interna por la derecha y centra en corto sobre el extremo Steffenhaguen y es interceptado por el defensa Castellano. A nuestro juicio fue una acci&oacute;n contundente pero limpia. El extremo cae al c&eacute;sped y da muestras de dolor. Los jugadores amarillos protestan la jugada pero el &aacute;rbitro no se vuelve atr&aacute;s en su decisi&oacute;n.</p>
<p>La pena m&aacute;xima fue ejecutada por Patzke dando el bal&oacute;n en el poste para luego entrar en la red.</p>
<p><img src="https://l10preunestawamb.blob.core.windows.net/lpa/images/legacy/201506/662x372a_05162808197.jpg" alt="" /></p>
<p><em>Patzke.</em></p>
<p>Poco despu&eacute;s llegar&iacute;a la mano de Witt que el colegiado no quiso ver.</p>
<p>En el cap&iacute;tulo de jugadores canarios destacados resaltamos la actuaci&oacute;n del guardameta Oregui y la l&iacute;nea de defensas compuesta por Hern&aacute;ndez, Tonono y Jos&eacute; Luis.</p>
<p><img src="https://l10preunestawamb.blob.core.windows.net/lpa/images/legacy/201506/662x372a_05162835198.jpg" alt="" /></p>
<p><em>Hern&aacute;ndez.</em></p>
<p><img src="https://l10preunestawamb.blob.core.windows.net/lpa/images/legacy/201506/662x372a_05162905199.jpg" alt="" /></p>
<p><em>Tonono.</em></p>
<p><img src="https://l10preunestawamb.blob.core.windows.net/lpa/images/legacy/201506/662x372a_05162932200.jpg" alt="" /></p>
<p><em>Jos&eacute; Luis.</em></p>
<p>A las &oacute;rdenes del &aacute;rbitro Sr. Hartmann los equipos presentaron las siguientes formaciones:</p>
<p>Hertha de Berl&iacute;n: Wolkman; Gross, Patzke (Loths), Witt; Wild, Enders; Altendoest (Veva), Ipta, Brungs, Graver y Steffenhaguen.</p>
<p>UD Las Palmas: Oregui; Hern&aacute;ndez, Tonono, Jos&eacute; Luis; Castellano, Niz; Le&oacute;n, Gilberto II, Trona (Jos&eacute; Juan), Germ&aacute;n y Gilberto I.</p>
<p>&nbsp;</p>
<p>La p&eacute;rdida del liderato ante el Real Madrid en el torneo liguero y la eliminaci&oacute;n de la Copa de Ciudades en Feria generar&iacute;a un ambiente enrarecido que se agravar&iacute;a con cuatro jornadas sin conocer la victoria: derrota de nuevo a domicilio ante el Valencia y como visitante ante el Celta de Vigo, y empates ante el Pontevedra y el Deportivo de La Coru&ntilde;a. Y aunque la victoria ante el CF Barcelona mitigar&iacute;a el descontento de los aficionados, la ulterior goleada ante el Real Madrid en el Bernab&eacute;u por cinco tantos a cero, Valencia, y sobre todo la imagen deplorable que ofrecer&iacute;a el equipo perdiendo a domicilio ante el Deportivo de La Coru&ntilde;a, desatar&iacute;a las iras de la afici&oacute;n que flameando pa&ntilde;uelos&nbsp; ped&iacute;a un cambio en la direcci&oacute;n t&eacute;cnica de nuestro equipo.</p>
<p>Luis Molowny, que ya ven&iacute;a siendo cuestionado desde aquel 2-4 ante el Real Madrid y la pol&eacute;mica y posteriores debates sobre la elecci&oacute;n del lanzamiento del penalti, era ya un t&eacute;cnico agotado y herido.</p>
<p>Todos aquellos aficionados que clamaban su salida al campo entre v&iacute;tores, confetis e instrumentos de viento en los partidos de la d&eacute;cada de los cincuenta ante el Atl&eacute;tico de Madrid y Valladolid; su clamoroso &eacute;xito con la Selecci&oacute;n Juvenil campeona de Espa&ntilde;a, o su posterior reinado con dos temporadas que a&uacute;n no han sido mejoradas por ning&uacute;n otro entrenador a lo largo de la historia, se convert&iacute;an ahora en sus mayores censores, pidiendo su fulgurante salida de la entidad.</p>
<p>El 26 de enero de 1970, , Luis Molowny dirigir&iacute;a a la UD Las Palmas por &uacute;ltima vez ante el Deportivo de La Coru&ntilde;a.</p>
<p>Paradigma de caballerosidad, no hizo falta llamarlo con la finalidad de comunicarle su cese. Tras la finalizaci&oacute;n del encuentro y siendo plenamente consciente de las exigencias del respetable y el enrarecido ambiente, presentar&iacute;a voluntariamente la dimisi&oacute;n de su cargo.</p>
<p>No exigi&oacute; ni siquiera su liquidaci&oacute;n al cancelar el contrato, cantidades que le fueron pagando en a&ntilde;os sucesivos, seg&uacute;n demostraremos en futuros documentos.</p>
<p>Se marchaba todo un caballero del deporte con quien la sociedad canaria tiene contra&iacute;da una perenne deuda de gratitud y reconocimiento, no s&oacute;lo por sus &eacute;xitos deportivos sino en su dimensi&oacute;n humana.</p>
<p>El entrenador palmero Rosendo Hern&aacute;ndez regresaba de nuevo a la isla para dirigir el equipo por segunda vez, clasific&aacute;ndolo en la &nbsp;novena posici&oacute;n de la tabla al t&eacute;rmino de la liga.</p>
<p>T&eacute;cnico extremadamente temperamental y de lenguaje explosivo en la cancha, era, sin embargo, afable, cordial y dialogante fuera de ella.</p>
<p><img src="https://l10preunestawamb.blob.core.windows.net/lpa/images/legacy/201506/662x372a_05163021208.jpg" alt="" /></p>
<p><em>En la instant&aacute;nea, el entrenador palmero Rosendo Hern&aacute;ndez a su llegada a la isla a efectos de hacerse cargo del equipo por segunda vez.</em></p>
<p>Sent&iacute;a por la cantera aut&eacute;ntica devoci&oacute;n, haciendo debutar en distintas &eacute;pocas a jugadores como Germ&aacute;n, Le&oacute;n y Rafael ante el Recreativo de Huelva, Jos&eacute; Crist&oacute;bal Correa ante la UD Levante, Meli&aacute;n y Carmel&iacute;n ante el Atl&eacute;tico de Madrid, etc&hellip;</p>
<p>De igual forma era un gran defensor del jugador en sus relaciones contractuales o de cualquier &iacute;ndole con los rectores de la entidad.</p>
<p>&nbsp;</p>
